(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
    window.css = require('css/index');
},{"css/index":2}],2:[function(require,module,exports){
    exports.parse = require('./lib/parse');
    exports.stringify = require('./lib/stringify');

},{"./lib/parse":3,"./lib/stringify":7}],3:[function(require,module,exports){
// http://www.w3.org/TR/CSS21/grammar.html
// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027
    var commentre = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g

    module.exports = function(css, options){
        options = options || {};

        /**
         * Positional.
         */

        var lineno = 1;
        var column = 1;

        /**
         * Update lineno and column based on `str`.
         */

        function updatePosition(str) {
            var lines = str.match(/\n/g);
            if (lines) lineno += lines.length;
            var i = str.lastIndexOf('\n');
            column = ~i ? str.length - i : column + str.length;
        }

        /**
         * Mark position and patch `node.position`.
         */

        function position() {
            var start = { line: lineno, column: column };
            return function(node){
                node.position = new Position(start);
                whitespace();
                return node;
            };
        }

        /**
         * Store position information for a node
         */

        function Position(start) {
            this.start = start;
            this.end = { line: lineno, column: column };
            this.source = options.source;
        }

        /**
         * Non-enumerable source string
         */

        Position.prototype.content = css;

        /**
         * Error `msg`.
         */

        function error(msg) {
            if (options.silent === true) {
                return false;
            }

            var err = new Error(msg + ' near line ' + lineno + ':' + column);
            err.filename = options.source;
            err.line = lineno;
            err.column = column;
            err.source = css;
            throw err;
        }

        /**
         * Parse stylesheet.
         */

        function stylesheet() {
            return {
                type: 'stylesheet',
                stylesheet: {
                    rules: rules()
                }
            };
        }

        /**
         * Opening brace.
         */

        function open() {
            return match(/^{\s*/);
        }

        /**
         * Closing brace.
         */

        function close() {
            return match(/^}/);
        }

        /**
         * Parse ruleset.
         */

        function rules() {
            var node;
            var rules = [];
            whitespace();
            comments(rules);
            while (css.length && css.charAt(0) != '}' && (node = atrule() || rule())) {
                if (node !== false) {
                    rules.push(node);
                    comments(rules);
                }
            }
            return rules;
        }

        /**
         * Match `re` and return captures.
         */

        function match(re) {
            var m = re.exec(css);
            if (!m) return;
            var str = m[0];
            updatePosition(str);
            css = css.slice(str.length);
            return m;
        }

        /**
         * Parse whitespace.
         */

        function whitespace() {
            match(/^\s*/);
        }

        /**
         * Parse comments;
         */

        function comments(rules) {
            var c;
            rules = rules || [];
            while (c = comment()) {
                if (c !== false) {
                    rules.push(c);
                }
            }
            return rules;
        }

        /**
         * Parse comment.
         */

        function comment() {
            var pos = position();
            if ('/' != css.charAt(0) || '*' != css.charAt(1)) return;

            var i = 2;
            while ("" != css.charAt(i) && ('*' != css.charAt(i) || '/' != css.charAt(i + 1))) ++i;
            i += 2;

            if ("" === css.charAt(i-1)) {
                return error('End of comment missing');
            }

            var str = css.slice(2, i - 2);
            column += 2;
            updatePosition(str);
            css = css.slice(i);
            column += 2;

            return pos({
                type: 'comment',
                comment: str
            });
        }

        /**
         * Parse selector.
         */

        function selector() {
            var m = match(/^([^{]+)/);
            if (!m) return;
            /* @fix Remove all comments from selectors
             * http://ostermiller.org/findcomment.html */
            return trim(m[0])
                .replace(/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*\/+/g, '')
                .replace(/(?:"[^"]*"|'[^']*')/g, function(m) {
                    return m.replace(/,/g, '\u200C');
                })
                .split(/\s*(?![^(]*\)),\s*/)
                .map(function(s) {
                    return s.replace(/\u200C/g, ',');
                });
        }

        /**
         * Parse declaration.
         */

        function declaration() {
            var pos = position();

            // prop
            var prop = match(/^(\*?[-#\/\*\\\w]+(\[[0-9a-z_-]+\])?)\s*/);
            if (!prop) return;
            prop = trim(prop[0]);

            // :
            if (!match(/^:\s*/)) return error("property missing ':'");

            // val
            var val = match(/^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^\)]*?\)|[^};])+)/);

            var ret = pos({
                type: 'declaration',
                property: prop.replace(commentre, ''),
                value: val ? trim(val[0]).replace(commentre, '') : ''
            });

            // ;
            match(/^[;\s]*/);

            return ret;
        }

        /**
         * Parse declarations.
         */

        function declarations() {
            var decls = [];

            if (!open()) return error("missing '{'");
            comments(decls);

            // declarations
            var decl;
            while (decl = declaration()) {
                if (decl !== false) {
                    decls.push(decl);
                    comments(decls);
                }
            }

            if (!close()) return error("missing '}'");
            return decls;
        }

        /**
         * Parse keyframe.
         */

        function keyframe() {
            var m;
            var vals = [];
            var pos = position();

            while (m = match(/^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/)) {
                vals.push(m[1]);
                match(/^,\s*/);
            }

            if (!vals.length) return;

            return pos({
                type: 'keyframe',
                values: vals,
                declarations: declarations()
            });
        }

        /**
         * Parse keyframes.
         */

        function atkeyframes() {
            var pos = position();
            var m = match(/^@([-\w]+)?keyframes */);

            if (!m) return;
            var vendor = m[1];

            // identifier
            var m = match(/^([-\w]+)\s*/);
            if (!m) return error("@keyframes missing name");
            var name = m[1];

            if (!open()) return error("@keyframes missing '{'");

            var frame;
            var frames = comments();
            while (frame = keyframe()) {
                frames.push(frame);
                frames = frames.concat(comments());
            }

            if (!close()) return error("@keyframes missing '}'");

            return pos({
                type: 'keyframes',
                name: name,
                vendor: vendor,
                keyframes: frames
            });
        }

        /**
         * Parse supports.
         */

        function atsupports() {
            var pos = position();
            var m = match(/^@supports *([^{]+)/);

            if (!m) return;
            var supports = trim(m[1]);

            if (!open()) return error("@supports missing '{'");

            var style = comments().concat(rules());

            if (!close()) return error("@supports missing '}'");

            return pos({
                type: 'supports',
                supports: supports,
                rules: style
            });
        }

        /**
         * Parse host.
         */

        function athost() {
            var pos = position();
            var m = match(/^@host */);

            if (!m) return;

            if (!open()) return error("@host missing '{'");

            var style = comments().concat(rules());

            if (!close()) return error("@host missing '}'");

            return pos({
                type: 'host',
                rules: style
            });
        }

        /**
         * Parse media.
         */

        function atmedia() {
            var pos = position();
            var m = match(/^@media *([^{]+)/);

            if (!m) return;
            var media = trim(m[1]);

            if (!open()) return error("@media missing '{'");

            var style = comments().concat(rules());

            if (!close()) return error("@media missing '}'");

            return pos({
                type: 'media',
                media: media,
                rules: style
            });
        }


        /**
         * Parse custom-media.
         */

        function atcustommedia() {
            var pos = position();
            var m = match(/^@custom-media (--[^\s]+) *([^{;]+);/);
            if (!m) return;

            return pos({
                type: 'custom-media',
                name: trim(m[1]),
                media: trim(m[2])
            });
        }

        /**
         * Parse paged media.
         */

        function atpage() {
            var pos = position();
            var m = match(/^@page */);
            if (!m) return;

            var sel = selector() || [];

            if (!open()) return error("@page missing '{'");
            var decls = comments();

            // declarations
            var decl;
            while (decl = declaration()) {
                decls.push(decl);
                decls = decls.concat(comments());
            }

            if (!close()) return error("@page missing '}'");

            return pos({
                type: 'page',
                selectors: sel,
                declarations: decls
            });
        }

        /**
         * Parse document.
         */

        function atdocument() {
            var pos = position();
            var m = match(/^@([-\w]+)?document *([^{]+)/);
            if (!m) return;

            var vendor = trim(m[1]);
            var doc = trim(m[2]);

            if (!open()) return error("@document missing '{'");

            var style = comments().concat(rules());

            if (!close()) return error("@document missing '}'");

            return pos({
                type: 'document',
                document: doc,
                vendor: vendor,
                rules: style
            });
        }

        /**
         * Parse font-face.
         */

        function atfontface() {
            var pos = position();
            var m = match(/^@font-face */);
            if (!m) return;

            if (!open()) return error("@font-face missing '{'");
            var decls = comments();

            // declarations
            var decl;
            while (decl = declaration()) {
                decls.push(decl);
                decls = decls.concat(comments());
            }

            if (!close()) return error("@font-face missing '}'");

            return pos({
                type: 'font-face',
                declarations: decls
            });
        }

        /**
         * Parse import
         */

        var atimport = _compileAtrule('import');

        /**
         * Parse charset
         */

        var atcharset = _compileAtrule('charset');

        /**
         * Parse namespace
         */

        var atnamespace = _compileAtrule('namespace');

        /**
         * Parse non-block at-rules
         */


        function _compileAtrule(name) {
            var re = new RegExp('^@' + name + ' *([^;\\n]+);');
            return function() {
                var pos = position();
                var m = match(re);
                if (!m) return;
                var ret = { type: name };
                ret[name] = m[1].trim();
                return pos(ret);
            }
        }

        /**
         * Parse at rule.
         */

        function atrule() {
            if (css[0] != '@') return;

            return atkeyframes()
                       || atmedia()
                       || atcustommedia()
                       || atsupports()
                       || atimport()
                       || atcharset()
                       || atnamespace()
                       || atdocument()
                       || atpage()
                       || athost()
                || atfontface();
        }

        /**
         * Parse rule.
         */

        function rule() {
            var pos = position();
            var sel = selector();

            if (!sel) return error('selector missing');
            comments();

            return pos({
                type: 'rule',
                selectors: sel,
                declarations: declarations()
            });
        }

        return addParent(stylesheet());
    };

    /**
     * Trim `str`.
     */

    function trim(str) {
        return str ? str.replace(/^\s+|\s+$/g, '') : '';
    }

    /**
     * Adds non-enumerable parent node reference to each node.
     */

    function addParent(obj, parent) {
        var isNode = obj && typeof obj.type === 'string';
        var childParent = isNode ? obj : parent;

        for (var k in obj) {
            var value = obj[k];
            if (Array.isArray(value)) {
                value.forEach(function(v) { addParent(v, childParent); });
            } else if (value && typeof value === 'object') {
                addParent(value, childParent);
            }
        }

        if (isNode) {
            Object.defineProperty(obj, 'parent', {
                configurable: true,
                writable: true,
                enumerable: false,
                value: parent || null
            });
        }

        return obj;
    }

},{}],4:[function(require,module,exports){

    /**
     * Expose `Compiler`.
     */

    module.exports = Compiler;

    /**
     * Initialize a compiler.
     *
     * @param {Type} name
     * @return {Type}
     * @api public
     */

    function Compiler(opts) {
        this.options = opts || {};
    }

    /**
     * Emit `str`
     */

    Compiler.prototype.emit = function(str) {
        return str;
    };

    /**
     * Visit `node`.
     */

    Compiler.prototype.visit = function(node){
        return this[node.type](node);
    };

    /**
     * Map visit over array of `nodes`, optionally using a `delim`
     */

    Compiler.prototype.mapVisit = function(nodes, delim){
        var buf = '';
        delim = delim || '';

        for (var i = 0, length = nodes.length; i < length; i++) {
            buf += this.visit(nodes[i]);
            if (delim && i < length - 1) buf += this.emit(delim);
        }

        return buf;
    };

},{}],5:[function(require,module,exports){

    /**
     * Module dependencies.
     */

    var Base = require('./compiler');

    /**
     * Expose compiler.
     */

    module.exports = Compiler;

    /**
     * Initialize a new `Compiler`.
     */

    function Compiler(options) {
        Base.call(this, options);
    }

    /**
     * Inherit from `Base.prototype`.
     */

    Compiler.prototype.__proto__ = Base.prototype;

    /**
     * Compile `node`.
     */

    Compiler.prototype.compile = function(node){
        return node.stylesheet
            .rules.map(this.visit, this)
            .join('');
    };

    /**
     * Visit comment node.
     */

    Compiler.prototype.comment = function(node){
        return this.emit('', node.position);
    };

    /**
     * Visit import node.
     */

    Compiler.prototype.import = function(node){
        return this.emit('@import ' + node.import + ';', node.position);
    };

    /**
     * Visit media node.
     */

    Compiler.prototype.media = function(node){
        return this.emit('@media ' + node.media, node.position)
                   + this.emit('{')
                   + this.mapVisit(node.rules)
            + this.emit('}');
    };

    /**
     * Visit document node.
     */

    Compiler.prototype.document = function(node){
        var doc = '@' + (node.vendor || '') + 'document ' + node.document;

        return this.emit(doc, node.position)
                   + this.emit('{')
                   + this.mapVisit(node.rules)
            + this.emit('}');
    };

    /**
     * Visit charset node.
     */

    Compiler.prototype.charset = function(node){
        return this.emit('@charset ' + node.charset + ';', node.position);
    };

    /**
     * Visit namespace node.
     */

    Compiler.prototype.namespace = function(node){
        return this.emit('@namespace ' + node.namespace + ';', node.position);
    };

    /**
     * Visit supports node.
     */

    Compiler.prototype.supports = function(node){
        return this.emit('@supports ' + node.supports, node.position)
                   + this.emit('{')
                   + this.mapVisit(node.rules)
            + this.emit('}');
    };

    /**
     * Visit keyframes node.
     */

    Compiler.prototype.keyframes = function(node){
        return this.emit('@'
                             + (node.vendor || '')
                             + 'keyframes '
            + node.name, node.position)
                   + this.emit('{')
                   + this.mapVisit(node.keyframes)
            + this.emit('}');
    };

    /**
     * Visit keyframe node.
     */

    Compiler.prototype.keyframe = function(node){
        var decls = node.declarations;

        return this.emit(node.values.join(','), node.position)
                   + this.emit('{')
                   + this.mapVisit(decls)
            + this.emit('}');
    };

    /**
     * Visit page node.
     */

    Compiler.prototype.page = function(node){
        var sel = node.selectors.length
            ? node.selectors.join(', ')
            : '';

        return this.emit('@page ' + sel, node.position)
                   + this.emit('{')
                   + this.mapVisit(node.declarations)
            + this.emit('}');
    };

    /**
     * Visit font-face node.
     */

    Compiler.prototype['font-face'] = function(node){
        return this.emit('@font-face', node.position)
                   + this.emit('{')
                   + this.mapVisit(node.declarations)
            + this.emit('}');
    };

    /**
     * Visit host node.
     */

    Compiler.prototype.host = function(node){
        return this.emit('@host', node.position)
                   + this.emit('{')
                   + this.mapVisit(node.rules)
            + this.emit('}');
    };

    /**
     * Visit custom-media node.
     */

    Compiler.prototype['custom-media'] = function(node){
        return this.emit('@custom-media ' + node.name + ' ' + node.media + ';', node.position);
    };

    /**
     * Visit rule node.
     */

    Compiler.prototype.rule = function(node){
        var decls = node.declarations;
        if (!decls.length) return '';

        return this.emit(node.selectors.join(','), node.position)
                   + this.emit('{')
                   + this.mapVisit(decls)
            + this.emit('}');
    };

    /**
     * Visit declaration node.
     */

    Compiler.prototype.declaration = function(node){
        return this.emit(node.property + ':' + node.value, node.position) + this.emit(';');
    };


},{"./compiler":4}],6:[function(require,module,exports){

    /**
     * Module dependencies.
     */

    var Base = require('./compiler');

    /**
     * Expose compiler.
     */

    module.exports = Compiler;

    /**
     * Initialize a new `Compiler`.
     */

    function Compiler(options) {
        options = options || {};
        Base.call(this, options);
        this.indentation = options.indent;
    }

    /**
     * Inherit from `Base.prototype`.
     */

    Compiler.prototype.__proto__ = Base.prototype;

    /**
     * Compile `node`.
     */

    Compiler.prototype.compile = function(node){
        return this.stylesheet(node);
    };

    /**
     * Visit stylesheet node.
     */

    Compiler.prototype.stylesheet = function(node){
        return this.mapVisit(node.stylesheet.rules, '\n\n');
    };

    /**
     * Visit comment node.
     */

    Compiler.prototype.comment = function(node){
        return this.emit(this.indent() + '/*' + node.comment + '*/', node.position);
    };

    /**
     * Visit import node.
     */

    Compiler.prototype.import = function(node){
        return this.emit('@import ' + node.import + ';', node.position);
    };

    /**
     * Visit media node.
     */

    Compiler.prototype.media = function(node){
        return this.emit('@media ' + node.media, node.position)
                   + this.emit(
                    ' {\n'
                    + this.indent(1))
                   + this.mapVisit(node.rules, '\n\n')
            + this.emit(
                    this.indent(-1)
                    + '\n}');
    };

    /**
     * Visit document node.
     */

    Compiler.prototype.document = function(node){
        var doc = '@' + (node.vendor || '') + 'document ' + node.document;

        return this.emit(doc, node.position)
                   + this.emit(
                    ' '
                    + ' {\n'
                    + this.indent(1))
                   + this.mapVisit(node.rules, '\n\n')
            + this.emit(
                    this.indent(-1)
                    + '\n}');
    };

    /**
     * Visit charset node.
     */

    Compiler.prototype.charset = function(node){
        return this.emit('@charset ' + node.charset + ';', node.position);
    };

    /**
     * Visit namespace node.
     */

    Compiler.prototype.namespace = function(node){
        return this.emit('@namespace ' + node.namespace + ';', node.position);
    };

    /**
     * Visit supports node.
     */

    Compiler.prototype.supports = function(node){
        return this.emit('@supports ' + node.supports, node.position)
                   + this.emit(
                    ' {\n'
                    + this.indent(1))
                   + this.mapVisit(node.rules, '\n\n')
            + this.emit(
                    this.indent(-1)
                    + '\n}');
    };

    /**
     * Visit keyframes node.
     */

    Compiler.prototype.keyframes = function(node){
        return this.emit('@' + (node.vendor || '') + 'keyframes ' + node.name, node.position)
                   + this.emit(
                    ' {\n'
                    + this.indent(1))
                   + this.mapVisit(node.keyframes, '\n')
            + this.emit(
                    this.indent(-1)
                    + '}');
    };

    /**
     * Visit keyframe node.
     */

    Compiler.prototype.keyframe = function(node){
        var decls = node.declarations;

        return this.emit(this.indent())
                   + this.emit(node.values.join(', '), node.position)
                   + this.emit(
                    ' {\n'
                    + this.indent(1))
                   + this.mapVisit(decls, '\n')
            + this.emit(
                    this.indent(-1)
                    + '\n'
                    + this.indent() + '}\n');
    };

    /**
     * Visit page node.
     */

    Compiler.prototype.page = function(node){
        var sel = node.selectors.length
            ? node.selectors.join(', ') + ' '
            : '';

        return this.emit('@page ' + sel, node.position)
                   + this.emit('{\n')
                   + this.emit(this.indent(1))
                   + this.mapVisit(node.declarations, '\n')
                   + this.emit(this.indent(-1))
            + this.emit('\n}');
    };

    /**
     * Visit font-face node.
     */

    Compiler.prototype['font-face'] = function(node){
        return this.emit('@font-face ', node.position)
                   + this.emit('{\n')
                   + this.emit(this.indent(1))
                   + this.mapVisit(node.declarations, '\n')
                   + this.emit(this.indent(-1))
            + this.emit('\n}');
    };

    /**
     * Visit host node.
     */

    Compiler.prototype.host = function(node){
        return this.emit('@host', node.position)
                   + this.emit(
                    ' {\n'
                    + this.indent(1))
                   + this.mapVisit(node.rules, '\n\n')
            + this.emit(
                    this.indent(-1)
                    + '\n}');
    };

    /**
     * Visit custom-media node.
     */

    Compiler.prototype['custom-media'] = function(node){
        return this.emit('@custom-media ' + node.name + ' ' + node.media + ';', node.position);
    };

    /**
     * Visit rule node.
     */

    Compiler.prototype.rule = function(node){
        var indent = this.indent();
        var decls = node.declarations;
        if (!decls.length) return '';

        return this.emit(node.selectors.map(function(s){ return indent + s }).join(',\n'), node.position)
                   + this.emit(' {\n')
                   + this.emit(this.indent(1))
                   + this.mapVisit(decls, '\n')
                   + this.emit(this.indent(-1))
            + this.emit('\n' + this.indent() + '}');
    };

    /**
     * Visit declaration node.
     */

    Compiler.prototype.declaration = function(node){
        return this.emit(this.indent())
                   + this.emit(node.property + ': ' + node.value, node.position)
            + this.emit(';');
    };

    /**
     * Increase, decrease or return current indentation.
     */

    Compiler.prototype.indent = function(level) {
        this.level = this.level || 1;

        if (null != level) {
            this.level += level;
            return '';
        }

        return Array(this.level).join(this.indentation || '  ');
    };

},{"./compiler":4}],7:[function(require,module,exports){

    /**
     * Module dependencies.
     */

    var Compressed = require('./compress');
    var Identity = require('./identity');

    /**
     * Stringfy the given AST `node`.
     *
     * Options:
     *
     *  - `compress` space-optimized output
     *  - `sourcemap` return an object with `.code` and `.map`
     *
     * @param {Object} node
     * @param {Object} [options]
     * @return {String}
     * @api public
     */

    module.exports = function(node, options){
        options = options || {};

        var compiler = options.compress
            ? new Compressed(options)
            : new Identity(options);

        // source maps
        if (options.sourcemap) {
            var sourcemaps = require('./source-map-support');
            sourcemaps(compiler);

            var code = compiler.compile(node);
            compiler.applySourceMaps();
            return { code: code, map: compiler.map.toJSON() };
        }

        var code = compiler.compile(node);
        return code;
    };

},{"./compress":5,"./identity":6,"./source-map-support":8}],8:[function(require,module,exports){

    /**
     * Module dependencies.
     */

    var SourceMap = require('source-map').SourceMapGenerator;
    var SourceMapConsumer = require('source-map').SourceMapConsumer;
    var sourceMapResolve = require('source-map-resolve');
    var urix = require('urix');
    var fs = require('fs');
    var path = require('path');

    /**
     * Expose `mixin()`.
     */

    module.exports = mixin;

    /**
     * Mixin source map support into `compiler`.
     *
     * @param {Compiler} compiler
     * @api public
     */

    function mixin(compiler) {
        compiler._comment = compiler.comment;
        compiler.map = new SourceMap();
        compiler.position = { line: 1, column: 1 };
        compiler.files = {};
        for (var k in exports) compiler[k] = exports[k];
    }

    /**
     * Update position.
     *
     * @param {String} str
     * @api private
     */

    exports.updatePosition = function(str) {
        var lines = str.match(/\n/g);
        if (lines) this.position.line += lines.length;
        var i = str.lastIndexOf('\n');
        this.position.column = ~i ? str.length - i : this.position.column + str.length;
    };

    /**
     * Emit `str`.
     *
     * @param {String} str
     * @param {Object} [pos]
     * @return {String}
     * @api private
     */

    exports.emit = function(str, pos) {
        if (pos) {
            var sourceFile = urix(pos.source || 'source.css');

            this.map.addMapping({
                source: sourceFile,
                generated: {
                    line: this.position.line,
                    column: Math.max(this.position.column - 1, 0)
                },
                original: {
                    line: pos.start.line,
                    column: pos.start.column - 1
                }
            });

            this.addFile(sourceFile, pos);
        }

        this.updatePosition(str);

        return str;
    };

    /**
     * Adds a file to the source map output if it has not already been added
     * @param {String} file
     * @param {Object} pos
     */

    exports.addFile = function(file, pos) {
        if (typeof pos.content !== 'string') return;
        if (Object.prototype.hasOwnProperty.call(this.files, file)) return;

        this.files[file] = pos.content;
    };

    /**
     * Applies any original source maps to the output and embeds the source file
     * contents in the source map.
     */

    exports.applySourceMaps = function() {
        Object.keys(this.files).forEach(function(file) {
            var content = this.files[file];
            this.map.setSourceContent(file, content);

            var originalMap = sourceMapResolve.resolveSync(
                content, file, fs.readFileSync);
            if (originalMap) {
                var map = new SourceMapConsumer(originalMap.map);
                var relativeTo = originalMap.sourcesRelativeTo;
                this.map.applySourceMap(map, file, urix(path.dirname(relativeTo)));
            }
        }, this);
    };

    /**
     * Process comments, drops sourceMap comments.
     * @param {Object} node
     */

    exports.comment = function(node) {
        if (/^# sourceMappingURL=/.test(node.comment))
            return this.emit('', node.position);
        else
            return this._comment(node);
    };

},{"fs":23,"path":24,"source-map":12,"source-map-resolve":11,"urix":22}],9:[function(require,module,exports){
// Copyright 2014 Simon Lydell
// X11 (“MIT”) Licensed. (See LICENSE.)

    void (function(root, factory) {
        if (typeof define === "function" && define.amd) {
            define(factory)
        } else if (typeof exports === "object") {
            module.exports = factory()
        } else {
            root.resolveUrl = factory()
        }
    }(this, function() {

        function resolveUrl(/* ...urls */) {
            var numUrls = arguments.length

            if (numUrls === 0) {
                throw new Error("resolveUrl requires at least one argument; got none.")
            }

            var base = document.createElement("base")
            base.href = arguments[0]

            if (numUrls === 1) {
                return base.href
            }

            var head = document.getElementsByTagName("head")[0]
            head.insertBefore(base, head.firstChild)

            var a = document.createElement("a")
            var resolved

            for (var index = 1; index < numUrls; index++) {
                a.href = arguments[index]
                resolved = a.href
                base.href = resolved
            }

            head.removeChild(base)

            return resolved
        }

        return resolveUrl

    }));

},{}],10:[function(require,module,exports){
// Copyright 2014 Simon Lydell

    void (function(root, factory) {
        if (typeof define === "function" && define.amd) {
            define(factory)
        } else if (typeof exports === "object") {
            module.exports = factory()
        } else {
            root.sourceMappingURL = factory()
        }
    }(this, function(undefined) {

        var innerRegex = /[#@] sourceMappingURL=([^\s'"]*)/
        var newlineRegex = /\r\n?|\n/

        var regex = RegExp(
                "(^|(?:" + newlineRegex.source + "))" +
                "(?:" +
                "/\\*" +
                "(?:\\s*(?:" + newlineRegex.source + ")(?://)?)?" +
                "(?:" + innerRegex.source + ")" +
                "\\s*" +
                "\\*/" +
                "|" +
                "//(?:" + innerRegex.source + ")" +
                ")" +
                "\\s*$"
        )

        function SourceMappingURL(commentSyntax) {
            this._commentSyntax = commentSyntax
        }

        SourceMappingURL.prototype.regex = regex
        SourceMappingURL.prototype._innerRegex = innerRegex
        SourceMappingURL.prototype._newlineRegex = newlineRegex

        SourceMappingURL.prototype.get = function(code) {
            var match = code.match(this.regex)
            if (!match) {
                return null
            }
            return match[2] || match[3] || ""
        }

        SourceMappingURL.prototype.set = function(code, url, commentSyntax) {
            if (!commentSyntax) {
                commentSyntax = this._commentSyntax
            }
            // Use a newline present in the code, or fall back to '\n'.
            var newline = String(code.match(this._newlineRegex) || "\n")
            var open = commentSyntax[0], close = commentSyntax[1] || ""
            code = this.remove(code)
            return code + newline + open + "# sourceMappingURL=" + url + close
        }

        SourceMappingURL.prototype.remove = function(code) {
            return code.replace(this.regex, "")
        }

        SourceMappingURL.prototype.insertBefore = function(code, string) {
            var match = code.match(this.regex)
            if (match) {
                var hasNewline = Boolean(match[1])
                return code.slice(0, match.index) +
                       string +
                       (hasNewline ? "" : "\n") +
                       code.slice(match.index)
            } else {
                return code + string
            }
        }

        SourceMappingURL.prototype.SourceMappingURL = SourceMappingURL

        return new SourceMappingURL(["/*", " */"])

    }));

},{}],11:[function(require,module,exports){
// Copyright 2014 Simon Lydell
// X11 (“MIT”) Licensed. (See LICENSE.)

// Note: source-map-resolve.js is generated from source-map-resolve-node.js and
// source-map-resolve-template.js. Only edit the two latter files, _not_
// source-map-resolve.js!

    void (function(root, factory) {
        if (typeof define === "function" && define.amd) {
            define(["source-map-url", "resolve-url"], factory)
        } else if (typeof exports === "object") {
            var sourceMappingURL = require("source-map-url")
            var resolveUrl = require("resolve-url")
            module.exports = factory(sourceMappingURL, resolveUrl)
        } else {
            root.sourceMapResolve = factory(root.sourceMappingURL, root.resolveUrl)
        }
    }(this, function(sourceMappingURL, resolveUrl) {

        function callbackAsync(callback, error, result) {
            setImmediate(function() { callback(error, result) })
        }

        function sig(name, codeOrMap, url, read, callback) {
            var type = (name.indexOf("Sources") >= 0 ? "map" : "code")

            var throwError = function(num, what, got) {
                throw new Error(
                        name + " requires argument " + num + " to be " + what + ". Got:\n" + got
                )
            }

            if (type === "map") {
                if (typeof codeOrMap !== "object" || codeOrMap === null) {
                    throwError(1, "a source map", codeOrMap)
                }
            } else {
                if (typeof codeOrMap !== "string") {
                    throwError(1, "some code", codeOrMap)
                }
            }
            if (typeof url !== "string") {
                throwError(2, "the " + type + " url", url)
            }
            if (typeof read !== "function") {
                throwError(3, "a reading function", read)
            }
            if (arguments.length === 1 + 4 && typeof callback !== "function") {
                throwError(4, "a callback function", callback)
            }
        }

        function parseMapToJSON(string) {
            return JSON.parse(string.replace(/^\)\]\}'/, ""))
        }



        function resolveSourceMap(code, codeUrl, read, callback) {
            sig("resolveSourceMap", code, codeUrl, read, callback)
            var mapData
            try {
                mapData = resolveSourceMapHelper(code, codeUrl)
            } catch (error) {
                return callbackAsync(callback, error)
            }
            if (!mapData || mapData.map) {
                return callbackAsync(callback, null, mapData)
            }
            read(mapData.url, function(error, result) {
                if (error) {
                    return callback(error)
                }
                try {
                    mapData.map = parseMapToJSON(String(result))
                } catch (error) {
                    return callback(error)
                }
                callback(null, mapData)
            })
        }

        function resolveSourceMapSync(code, codeUrl, read) {
            sig("resolveSourceMapSync", code, codeUrl, read)
            var mapData = resolveSourceMapHelper(code, codeUrl)
            if (!mapData || mapData.map) {
                return mapData
            }
            mapData.map = parseMapToJSON(String(read(mapData.url)))
            return mapData
        }

        var dataUriRegex = /^data:([^,;]*)(;[^,;]*)*(?:,(.*))?$/
        var jsonMimeTypeRegex = /^(?:application|text)\/json$/

        function resolveSourceMapHelper(code, codeUrl) {
            var url = sourceMappingURL.get(code)
            if (!url) {
                return null
            }

            var dataUri = url.match(dataUriRegex)
            if (dataUri) {
                var mimeType = dataUri[1]
                var lastParameter = dataUri[2]
                var encoded = dataUri[3]
                if (!jsonMimeTypeRegex.test(mimeType)) {
                    throw new Error("Unuseful data uri mime type: " + (mimeType || "text/plain"))
                }
                return {
                    sourceMappingURL: url,
                    url: null,
                    sourcesRelativeTo: codeUrl,
                    map: parseMapToJSON(lastParameter === ";base64" ? atob(encoded) : decodeURIComponent(encoded))
                }
            }

            var mapUrl = resolveUrl(codeUrl, url)
            return {
                sourceMappingURL: url,
                url: mapUrl,
                sourcesRelativeTo: mapUrl,
                map: null
            }
        }



        function resolveSources(map, mapUrl, read, callback) {
            sig("resolveSources", map, mapUrl, read, callback)
            var pending = map.sources.length
            var errored = false
            var sources = []

            var done = function(error) {
                if (errored) {
                    return
                }
                if (error) {
                    errored = true
                    return callback(error)
                }
                pending--
                if (pending === 0) {
                    callback(null, sources)
                }
            }

            resolveSourcesHelper(map, mapUrl, function(fullUrl, sourceContent, index) {
                if (typeof sourceContent === "string") {
                    sources[index] = sourceContent
                    callbackAsync(done, null)
                } else {
                    read(fullUrl, function(error, result) {
                        sources[index] = String(result)
                        done(error)
                    })
                }
            })
        }

        function resolveSourcesSync(map, mapUrl, read) {
            sig("resolveSourcesSync", map, mapUrl, read)
            var sources = []
            resolveSourcesHelper(map, mapUrl, function(fullUrl, sourceContent, index) {
                if (typeof sourceContent === "string") {
                    sources[index] = sourceContent
                } else {
                    sources[index] = String(read(fullUrl))
                }
            })
            return sources
        }

        var endingSlash = /\/?$/

        function resolveSourcesHelper(map, mapUrl, fn) {
            var fullUrl
            var sourceContent
            for (var index = 0, len = map.sources.length; index < len; index++) {
                if (map.sourceRoot) {
                    // Make sure that the sourceRoot ends with a slash, so that `/scripts/subdir` becomes
                    // `/scripts/subdir/<source>`, not `/scripts/<source>`. Pointing to a file as source root
                    // does not make sense.
                    fullUrl = resolveUrl(mapUrl, map.sourceRoot.replace(endingSlash, "/"), map.sources[index])
                } else {
                    fullUrl = resolveUrl(mapUrl, map.sources[index])
                }
                sourceContent = (map.sourcesContent || [])[index]
                fn(fullUrl, sourceContent, index)
            }
        }



        function resolve(code, codeUrl, read, callback) {
            sig("resolve", code, codeUrl, read, callback)
            resolveSourceMap(code, codeUrl, read, function(error, mapData) {
                if (error) {
                    return callback(error)
                }
                if (!mapData) {
                    return callback(null, null)
                }
                resolveSources(mapData.map, mapData.sourcesRelativeTo, read, function(error, sources) {
                    if (error) {
                        return callback(error)
                    }
                    mapData.sources = sources
                    callback(null, mapData)
                })
            })
        }

        function resolveSync(code, codeUrl, read) {
            sig("resolveSync", code, codeUrl, read)
            var mapData = resolveSourceMapSync(code, codeUrl, read)
            if (!mapData) {
                return null
            }
            mapData.sources = resolveSourcesSync(mapData.map, mapData.sourcesRelativeTo, read)
            return mapData
        }



        return {
            resolveSourceMap:     resolveSourceMap,
            resolveSourceMapSync: resolveSourceMapSync,
            resolveSources:       resolveSources,
            resolveSourcesSync:   resolveSourcesSync,
            resolve:              resolve,
            resolveSync:          resolveSync
        }

    }));

},{"resolve-url":9,"source-map-url":10}],12:[function(require,module,exports){
    /*
     * Copyright 2009-2011 Mozilla Foundation and contributors
     * Licensed under the New BSD license. See LICENSE.txt or:
     * http://opensource.org/licenses/BSD-3-Clause
     */
    exports.SourceMapGenerator = require('./source-map/source-map-generator').SourceMapGenerator;
    exports.SourceMapConsumer = require('./source-map/source-map-consumer').SourceMapConsumer;
    exports.SourceNode = require('./source-map/source-node').SourceNode;

},{"./source-map/source-map-consumer":17,"./source-map/source-map-generator":18,"./source-map/source-node":19}],13:[function(require,module,exports){
    /* -*- Mode: js; js-indent-level: 2; -*- */
    /*
     * Copyright 2011 Mozilla Foundation and contributors
     * Licensed under the New BSD license. See LICENSE or:
     * http://opensource.org/licenses/BSD-3-Clause
     */
    if (typeof define !== 'function') {
        var define = require('amdefine')(module, require);
    }
    define(function (require, exports, module) {

        var util = require('./util');

        /**
         * A data structure which is a combination of an array and a set. Adding a new
         * member is O(1), testing for membership is O(1), and finding the index of an
         * element is O(1). Removing elements from the set is not supported. Only
         * strings are supported for membership.
         */
        function ArraySet() {
            this._array = [];
            this._set = {};
        }

        /**
         * Static method for creating ArraySet instances from an existing array.
         */
        ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
            var set = new ArraySet();
            for (var i = 0, len = aArray.length; i < len; i++) {
                set.add(aArray[i], aAllowDuplicates);
            }
            return set;
        };

        /**
         * Add the given string to this set.
         *
         * @param String aStr
         */
        ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
            var isDuplicate = this.has(aStr);
            var idx = this._array.length;
            if (!isDuplicate || aAllowDuplicates) {
                this._array.push(aStr);
            }
            if (!isDuplicate) {
                this._set[util.toSetString(aStr)] = idx;
            }
        };

        /**
         * Is the given string a member of this set?
         *
         * @param String aStr
         */
        ArraySet.prototype.has = function ArraySet_has(aStr) {
            return Object.prototype.hasOwnProperty.call(this._set,
                util.toSetString(aStr));
        };

        /**
         * What is the index of the given string in the array?
         *
         * @param String aStr
         */
        ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
            if (this.has(aStr)) {
                return this._set[util.toSetString(aStr)];
            }
            throw new Error('"' + aStr + '" is not in the set.');
        };

        /**
         * What is the element at the given index?
         *
         * @param Number aIdx
         */
        ArraySet.prototype.at = function ArraySet_at(aIdx) {
            if (aIdx >= 0 && aIdx < this._array.length) {
                return this._array[aIdx];
            }
            throw new Error('No element indexed by ' + aIdx);
        };

        /**
         * Returns the array representation of this set (which has the proper indices
         * indicated by indexOf). Note that this is a copy of the internal array used
         * for storing the members so that no one can mess with internal state.
         */
        ArraySet.prototype.toArray = function ArraySet_toArray() {
            return this._array.slice();
        };

        exports.ArraySet = ArraySet;

    });

},{"./util":20,"amdefine":21}],14:[function(require,module,exports){
    /* -*- Mode: js; js-indent-level: 2; -*- */
    /*
     * Copyright 2011 Mozilla Foundation and contributors
     * Licensed under the New BSD license. See LICENSE or:
     * http://opensource.org/licenses/BSD-3-Clause
     *
     * Based on the Base 64 VLQ implementation in Closure Compiler:
     * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
     *
     * Copyright 2011 The Closure Compiler Authors. All rights reserved.
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions are
     * met:
     *
     *  * Redistributions of source code must retain the above copyright
     *    notice, this list of conditions and the following disclaimer.
     *  * Redistributions in binary form must reproduce the above
     *    copyright notice, this list of conditions and the following
     *    disclaimer in the documentation and/or other materials provided
     *    with the distribution.
     *  * Neither the name of Google Inc. nor the names of its
     *    contributors may be used to endorse or promote products derived
     *    from this software without specific prior written permission.
     *
     * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     */
    if (typeof define !== 'function') {
        var define = require('amdefine')(module, require);
    }
    define(function (require, exports, module) {

        var base64 = require('./base64');

        // A single base 64 digit can contain 6 bits of data. For the base 64 variable
        // length quantities we use in the source map spec, the first bit is the sign,
        // the next four bits are the actual value, and the 6th bit is the
        // continuation bit. The continuation bit tells us whether there are more
        // digits in this value following this digit.
        //
        //   Continuation
        //   |    Sign
        //   |    |
        //   V    V
        //   101011

        var VLQ_BASE_SHIFT = 5;

        // binary: 100000
        var VLQ_BASE = 1 << VLQ_BASE_SHIFT;

        // binary: 011111
        var VLQ_BASE_MASK = VLQ_BASE - 1;

        // binary: 100000
        var VLQ_CONTINUATION_BIT = VLQ_BASE;

        /**
         * Converts from a two-complement value to a value where the sign bit is
         * is placed in the least significant bit.  For example, as decimals:
         *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
         *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
         */
        function toVLQSigned(aValue) {
            return aValue < 0
                ? ((-aValue) << 1) + 1
                : (aValue << 1) + 0;
        }

        /**
         * Converts to a two-complement value from a value where the sign bit is
         * is placed in the least significant bit.  For example, as decimals:
         *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
         *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
         */
        function fromVLQSigned(aValue) {
            var isNegative = (aValue & 1) === 1;
            var shifted = aValue >> 1;
            return isNegative
                ? -shifted
                : shifted;
        }

        /**
         * Returns the base 64 VLQ encoded value.
         */
        exports.encode = function base64VLQ_encode(aValue) {
            var encoded = "";
            var digit;

            var vlq = toVLQSigned(aValue);

            do {
                digit = vlq & VLQ_BASE_MASK;
                vlq >>>= VLQ_BASE_SHIFT;
                if (vlq > 0) {
                    // There are still more digits in this value, so we must make sure the
                    // continuation bit is marked.
                    digit |= VLQ_CONTINUATION_BIT;
                }
                encoded += base64.encode(digit);
            } while (vlq > 0);

            return encoded;
        };

        /**
         * Decodes the next base 64 VLQ value from the given string and returns the
         * value and the rest of the string.
         */
        exports.decode = function base64VLQ_decode(aStr) {
            var i = 0;
            var strLen = aStr.length;
            var result = 0;
            var shift = 0;
            var continuation, digit;

            do {
                if (i >= strLen) {
                    throw new Error("Expected more digits in base 64 VLQ value.");
                }
                digit = base64.decode(aStr.charAt(i++));
                continuation = !!(digit & VLQ_CONTINUATION_BIT);
                digit &= VLQ_BASE_MASK;
                result = result + (digit << shift);
                shift += VLQ_BASE_SHIFT;
            } while (continuation);

            return {
                value: fromVLQSigned(result),
                rest: aStr.slice(i)
            };
        };

    });

},{"./base64":15,"amdefine":21}],15:[function(require,module,exports){
    /* -*- Mode: js; js-indent-level: 2; -*- */
    /*
     * Copyright 2011 Mozilla Foundation and contributors
     * Licensed under the New BSD license. See LICENSE or:
     * http://opensource.org/licenses/BSD-3-Clause
     */
    if (typeof define !== 'function') {
        var define = require('amdefine')(module, require);
    }
    define(function (require, exports, module) {

        var charToIntMap = {};
        var intToCharMap = {};

        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
            .split('')
            .forEach(function (ch, index) {
                charToIntMap[ch] = index;
                intToCharMap[index] = ch;
            });

        /**
         * Encode an integer in the range of 0 to 63 to a single base 64 digit.
         */
        exports.encode = function base64_encode(aNumber) {
            if (aNumber in intToCharMap) {
                return intToCharMap[aNumber];
            }
            throw new TypeError("Must be between 0 and 63: " + aNumber);
        };

        /**
         * Decode a single base 64 digit to an integer.
         */
        exports.decode = function base64_decode(aChar) {
            if (aChar in charToIntMap) {
                return charToIntMap[aChar];
            }
            throw new TypeError("Not a valid base 64 digit: " + aChar);
        };

    });

},{"amdefine":21}],16:[function(require,module,exports){
    /* -*- Mode: js; js-indent-level: 2; -*- */
    /*
     * Copyright 2011 Mozilla Foundation and contributors
     * Licensed under the New BSD license. See LICENSE or:
     * http://opensource.org/licenses/BSD-3-Clause
     */
    if (typeof define !== 'function') {
        var define = require('amdefine')(module, require);
    }
    define(function (require, exports, module) {

        /**
         * Recursive implementation of binary search.
         *
         * @param aLow Indices here and lower do not contain the needle.
         * @param aHigh Indices here and higher do not contain the needle.
         * @param aNeedle The element being searched for.
         * @param aHaystack The non-empty array being searched.
         * @param aCompare Function which takes two elements and returns -1, 0, or 1.
         */
        function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare) {
            // This function terminates when one of the following is true:
            //
            //   1. We find the exact element we are looking for.
            //
            //   2. We did not find the exact element, but we can return the next
            //      closest element that is less than that element.
            //
            //   3. We did not find the exact element, and there is no next-closest
            //      element which is less than the one we are searching for, so we
            //      return null.
            var mid = Math.floor((aHigh - aLow) / 2) + aLow;
            var cmp = aCompare(aNeedle, aHaystack[mid], true);
            if (cmp === 0) {
                // Found the element we are looking for.
                return aHaystack[mid];
            }
            else if (cmp > 0) {
                // aHaystack[mid] is greater than our needle.
                if (aHigh - mid > 1) {
                    // The element is in the upper half.
                    return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare);
                }
                // We did not find an exact match, return the next closest one
                // (termination case 2).
                return aHaystack[mid];
            }
            else {
                // aHaystack[mid] is less than our needle.
                if (mid - aLow > 1) {
                    // The element is in the lower half.
                    return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare);
                }
                // The exact needle element was not found in this haystack. Determine if
                // we are in termination case (2) or (3) and return the appropriate thing.
                return aLow < 0
                    ? null
                    : aHaystack[aLow];
            }
        }

        /**
         * This is an implementation of binary search which will always try and return
         * the next lowest value checked if there is no exact hit. This is because
         * mappings between original and generated line/col pairs are single points,
         * and there is an implicit region between each of them, so a miss just means
         * that you aren't on the very start of a region.
         *
         * @param aNeedle The element you are looking for.
         * @param aHaystack The array that is being searched.
         * @param aCompare A function which takes the needle and an element in the
         *     array and returns -1, 0, or 1 depending on whether the needle is less
         *     than, equal to, or greater than the element, respectively.
         */
        exports.search = function search(aNeedle, aHaystack, aCompare) {
            return aHaystack.length > 0
                ? recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare)
                : null;
        };

    });

},{"amdefine":21}],17:[function(require,module,exports){
    /* -*- Mode: js; js-indent-level: 2; -*- */
    /*
     * Copyright 2011 Mozilla Foundation and contributors
     * Licensed under the New BSD license. See LICENSE or:
     * http://opensource.org/licenses/BSD-3-Clause
     */
    if (typeof define !== 'function') {
        var define = require('amdefine')(module, require);
    }
    define(function (require, exports, module) {

        var util = require('./util');
        var binarySearch = require('./binary-search');
        var ArraySet = require('./array-set').ArraySet;
        var base64VLQ = require('./base64-vlq');

        /**
         * A SourceMapConsumer instance represents a parsed source map which we can
         * query for information about the original file positions by giving it a file
         * position in the generated source.
         *
         * The only parameter is the raw source map (either as a JSON string, or
         * already parsed to an object). According to the spec, source maps have the
         * following attributes:
         *
         *   - version: Which version of the source map spec this map is following.
         *   - sources: An array of URLs to the original source files.
         *   - names: An array of identifiers which can be referrenced by individual mappings.
         *   - sourceRoot: Optional. The URL root from which all sources are relative.
         *   - sourcesContent: Optional. An array of contents of the original source files.
         *   - mappings: A string of base64 VLQs which contain the actual mappings.
         *   - file: Optional. The generated file this source map is associated with.
         *
         * Here is an example source map, taken from the source map spec[0]:
         *
         *     {
   *       version : 3,
   *       file: "out.js",
   *       sourceRoot : "",
   *       sources: ["foo.js", "bar.js"],
   *       names: ["src", "maps", "are", "fun"],
   *       mappings: "AA,AB;;ABCDE;"
   *     }
         *
         * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
         */
        function SourceMapConsumer(aSourceMap) {
            var sourceMap = aSourceMap;
            if (typeof aSourceMap === 'string') {
                sourceMap = JSON.parse(aSourceMap.replace(/^\)\]\}'/, ''));
            }

            var version = util.getArg(sourceMap, 'version');
            var sources = util.getArg(sourceMap, 'sources');
            // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
            // requires the array) to play nice here.
            var names = util.getArg(sourceMap, 'names', []);
            var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
            var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
            var mappings = util.getArg(sourceMap, 'mappings');
            var file = util.getArg(sourceMap, 'file', null);

            // Once again, Sass deviates from the spec and supplies the version as a
            // string rather than a number, so we use loose equality checking here.
            if (version != this._version) {
                throw new Error('Unsupported version: ' + version);
            }

            // Pass `true` below to allow duplicate names and sources. While source maps
            // are intended to be compressed and deduplicated, the TypeScript compiler
            // sometimes generates source maps with duplicates in them. See Github issue
            // #72 and bugzil.la/889492.
            this._names = ArraySet.fromArray(names, true);
            this._sources = ArraySet.fromArray(sources, true);

            this.sourceRoot = sourceRoot;
            this.sourcesContent = sourcesContent;
            this._mappings = mappings;
            this.file = file;
        }

        /**
         * Create a SourceMapConsumer from a SourceMapGenerator.
         *
         * @param SourceMapGenerator aSourceMap
         *        The source map that will be consumed.
         * @returns SourceMapConsumer
         */
        SourceMapConsumer.fromSourceMap =
        function SourceMapConsumer_fromSourceMap(aSourceMap) {
            var smc = Object.create(SourceMapConsumer.prototype);

            smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
            smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
            smc.sourceRoot = aSourceMap._sourceRoot;
            smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
                smc.sourceRoot);
            smc.file = aSourceMap._file;

            smc.__generatedMappings = aSourceMap._mappings.slice()
                .sort(util.compareByGeneratedPositions);
            smc.__originalMappings = aSourceMap._mappings.slice()
                .sort(util.compareByOriginalPositions);

            return smc;
        };

        /**
         * The version of the source mapping spec that we are consuming.
         */
        SourceMapConsumer.prototype._version = 3;

        /**
         * The list of original sources.
         */
        Object.defineProperty(SourceMapConsumer.prototype, 'sources', {
            get: function () {
                return this._sources.toArray().map(function (s) {
                    return this.sourceRoot != null ? util.join(this.sourceRoot, s) : s;
                }, this);
            }
        });

        // `__generatedMappings` and `__originalMappings` are arrays that hold the
        // parsed mapping coordinates from the source map's "mappings" attribute. They
        // are lazily instantiated, accessed via the `_generatedMappings` and
        // `_originalMappings` getters respectively, and we only parse the mappings
        // and create these arrays once queried for a source location. We jump through
        // these hoops because there can be many thousands of mappings, and parsing
        // them is expensive, so we only want to do it if we must.
        //
        // Each object in the arrays is of the form:
        //
        //     {
        //       generatedLine: The line number in the generated code,
        //       generatedColumn: The column number in the generated code,
        //       source: The path to the original source file that generated this
        //               chunk of code,
        //       originalLine: The line number in the original source that
        //                     corresponds to this chunk of generated code,
        //       originalColumn: The column number in the original source that
        //                       corresponds to this chunk of generated code,
        //       name: The name of the original symbol which generated this chunk of
        //             code.
        //     }
        //
        // All properties except for `generatedLine` and `generatedColumn` can be
        // `null`.
        //
        // `_generatedMappings` is ordered by the generated positions.
        //
        // `_originalMappings` is ordered by the original positions.

        SourceMapConsumer.prototype.__generatedMappings = null;
        Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
            get: function () {
                if (!this.__generatedMappings) {
                    this.__generatedMappings = [];
                    this.__originalMappings = [];
                    this._parseMappings(this._mappings, this.sourceRoot);
                }

                return this.__generatedMappings;
            }
        });

        SourceMapConsumer.prototype.__originalMappings = null;
        Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
            get: function () {
                if (!this.__originalMappings) {
                    this.__generatedMappings = [];
                    this.__originalMappings = [];
                    this._parseMappings(this._mappings, this.sourceRoot);
                }

                return this.__originalMappings;
            }
        });

        /**
         * Parse the mappings in a string in to a data structure which we can easily
         * query (the ordered arrays in the `this.__generatedMappings` and
         * `this.__originalMappings` properties).
         */
        SourceMapConsumer.prototype._parseMappings =
        function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
            var generatedLine = 1;
            var previousGeneratedColumn = 0;
            var previousOriginalLine = 0;
            var previousOriginalColumn = 0;
            var previousSource = 0;
            var previousName = 0;
            var mappingSeparator = /^[,;]/;
            var str = aStr;
            var mapping;
            var temp;

            while (str.length > 0) {
                if (str.charAt(0) === ';') {
                    generatedLine++;
                    str = str.slice(1);
                    previousGeneratedColumn = 0;
                }
                else if (str.charAt(0) === ',') {
                    str = str.slice(1);
                }
                else {
                    mapping = {};
                    mapping.generatedLine = generatedLine;

                    // Generated column.
                    temp = base64VLQ.decode(str);
                    mapping.generatedColumn = previousGeneratedColumn + temp.value;
                    previousGeneratedColumn = mapping.generatedColumn;
                    str = temp.rest;

                    if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) {
                        // Original source.
                        temp = base64VLQ.decode(str);
                        mapping.source = this._sources.at(previousSource + temp.value);
                        previousSource += temp.value;
                        str = temp.rest;
                        if (str.length === 0 || mappingSeparator.test(str.charAt(0))) {
                            throw new Error('Found a source, but no line and column');
                        }

                        // Original line.
                        temp = base64VLQ.decode(str);
                        mapping.originalLine = previousOriginalLine + temp.value;
                        previousOriginalLine = mapping.originalLine;
                        // Lines are stored 0-based
                        mapping.originalLine += 1;
                        str = temp.rest;
                        if (str.length === 0 || mappingSeparator.test(str.charAt(0))) {
                            throw new Error('Found a source and line, but no column');
                        }

                        // Original column.
                        temp = base64VLQ.decode(str);
                        mapping.originalColumn = previousOriginalColumn + temp.value;
                        previousOriginalColumn = mapping.originalColumn;
                        str = temp.rest;

                        if (str.length > 0 && !mappingSeparator.test(str.charAt(0))) {
                            // Original name.
                            temp = base64VLQ.decode(str);
                            mapping.name = this._names.at(previousName + temp.value);
                            previousName += temp.value;
                            str = temp.rest;
                        }
                    }

                    this.__generatedMappings.push(mapping);
                    if (typeof mapping.originalLine === 'number') {
                        this.__originalMappings.push(mapping);
                    }
                }
            }

            this.__generatedMappings.sort(util.compareByGeneratedPositions);
            this.__originalMappings.sort(util.compareByOriginalPositions);
        };

        /**
         * Find the mapping that best matches the hypothetical "needle" mapping that
         * we are searching for in the given "haystack" of mappings.
         */
        SourceMapConsumer.prototype._findMapping =
        function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
                                               aColumnName, aComparator) {
            // To return the position we are searching for, we must first find the
            // mapping for the given position and then return the opposite position it
            // points to. Because the mappings are sorted, we can use binary search to
            // find the best mapping.

            if (aNeedle[aLineName] <= 0) {
                throw new TypeError('Line must be greater than or equal to 1, got '
                    + aNeedle[aLineName]);
            }
            if (aNeedle[aColumnName] < 0) {
                throw new TypeError('Column must be greater than or equal to 0, got '
                    + aNeedle[aColumnName]);
            }

            return binarySearch.search(aNeedle, aMappings, aComparator);
        };

        /**
         * Returns the original source, line, and column information for the generated
         * source's line and column positions provided. The only argument is an object
         * with the following properties:
         *
         *   - line: The line number in the generated source.
         *   - column: The column number in the generated source.
         *
         * and an object is returned with the following properties:
         *
         *   - source: The original source file, or null.
         *   - line: The line number in the original source, or null.
         *   - column: The column number in the original source, or null.
         *   - name: The original identifier, or null.
         */
        SourceMapConsumer.prototype.originalPositionFor =
        function SourceMapConsumer_originalPositionFor(aArgs) {
            var needle = {
                generatedLine: util.getArg(aArgs, 'line'),
                generatedColumn: util.getArg(aArgs, 'column')
            };

            var mapping = this._findMapping(needle,
                this._generatedMappings,
                "generatedLine",
                "generatedColumn",
                util.compareByGeneratedPositions);

            if (mapping && mapping.generatedLine === needle.generatedLine) {
                var source = util.getArg(mapping, 'source', null);
                if (source != null && this.sourceRoot != null) {
                    source = util.join(this.sourceRoot, source);
                }
                return {
                    source: source,
                    line: util.getArg(mapping, 'originalLine', null),
                    column: util.getArg(mapping, 'originalColumn', null),
                    name: util.getArg(mapping, 'name', null)
                };
            }

            return {
                source: null,
                line: null,
                column: null,
                name: null
            };
        };

        /**
         * Returns the original source content. The only argument is the url of the
         * original source file. Returns null if no original source content is
         * availible.
         */
        SourceMapConsumer.prototype.sourceContentFor =
        function SourceMapConsumer_sourceContentFor(aSource) {
            if (!this.sourcesContent) {
                return null;
            }

            if (this.sourceRoot != null) {
                aSource = util.relative(this.sourceRoot, aSource);
            }

            if (this._sources.has(aSource)) {
                return this.sourcesContent[this._sources.indexOf(aSource)];
            }

            var url;
            if (this.sourceRoot != null
                && (url = util.urlParse(this.sourceRoot))) {
                // XXX: file:// URIs and absolute paths lead to unexpected behavior for
                // many users. We can help them out when they expect file:// URIs to
                // behave like it would if they were running a local HTTP server. See
                // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
                var fileUriAbsPath = aSource.replace(/^file:\/\//, "");
                if (url.scheme == "file"
                    && this._sources.has(fileUriAbsPath)) {
                    return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
                }

                if ((!url.path || url.path == "/")
                    && this._sources.has("/" + aSource)) {
                    return this.sourcesContent[this._sources.indexOf("/" + aSource)];
                }
            }

            throw new Error('"' + aSource + '" is not in the SourceMap.');
        };

        /**
         * Returns the generated line and column information for the original source,
         * line, and column positions provided. The only argument is an object with
         * the following properties:
         *
         *   - source: The filename of the original source.
         *   - line: The line number in the original source.
         *   - column: The column number in the original source.
         *
         * and an object is returned with the following properties:
         *
         *   - line: The line number in the generated source, or null.
         *   - column: The column number in the generated source, or null.
         */
        SourceMapConsumer.prototype.generatedPositionFor =
        function SourceMapConsumer_generatedPositionFor(aArgs) {
            var needle = {
                source: util.getArg(aArgs, 'source'),
                originalLine: util.getArg(aArgs, 'line'),
                originalColumn: util.getArg(aArgs, 'column')
            };

            if (this.sourceRoot != null) {
                needle.source = util.relative(this.sourceRoot, needle.source);
            }

            var mapping = this._findMapping(needle,
                this._originalMappings,
                "originalLine",
                "originalColumn",
                util.compareByOriginalPositions);

            if (mapping) {
                return {
                    line: util.getArg(mapping, 'generatedLine', null),
                    column: util.getArg(mapping, 'generatedColumn', null)
                };
            }

            return {
                line: null,
                column: null
            };
        };

        SourceMapConsumer.GENERATED_ORDER = 1;
        SourceMapConsumer.ORIGINAL_ORDER = 2;

        /**
         * Iterate over each mapping between an original source/line/column and a
         * generated line/column in this source map.
         *
         * @param Function aCallback
         *        The function that is called with each mapping.
         * @param Object aContext
         *        Optional. If specified, this object will be the value of `this` every
         *        time that `aCallback` is called.
         * @param aOrder
         *        Either `SourceMapConsumer.GENERATED_ORDER` or
         *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
         *        iterate over the mappings sorted by the generated file's line/column
         *        order or the original's source/line/column order, respectively. Defaults to
         *        `SourceMapConsumer.GENERATED_ORDER`.
         */
        SourceMapConsumer.prototype.eachMapping =
        function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
            var context = aContext || null;
            var order = aOrder || SourceMapConsumer.GENERATED_ORDER;

            var mappings;
            switch (order) {
                case SourceMapConsumer.GENERATED_ORDER:
                    mappings = this._generatedMappings;
                    break;
                case SourceMapConsumer.ORIGINAL_ORDER:
                    mappings = this._originalMappings;
                    break;
                default:
                    throw new Error("Unknown order of iteration.");
            }

            var sourceRoot = this.sourceRoot;
            mappings.map(function (mapping) {
                var source = mapping.source;
                if (source != null && sourceRoot != null) {
                    source = util.join(sourceRoot, source);
                }
                return {
                    source: source,
                    generatedLine: mapping.generatedLine,
                    generatedColumn: mapping.generatedColumn,
                    originalLine: mapping.originalLine,
                    originalColumn: mapping.originalColumn,
                    name: mapping.name
                };
            }).forEach(aCallback, context);
        };

        exports.SourceMapConsumer = SourceMapConsumer;

    });

},{"./array-set":13,"./base64-vlq":14,"./binary-search":16,"./util":20,"amdefine":21}],18:[function(require,module,exports){
    /* -*- Mode: js; js-indent-level: 2; -*- */
    /*
     * Copyright 2011 Mozilla Foundation and contributors
     * Licensed under the New BSD license. See LICENSE or:
     * http://opensource.org/licenses/BSD-3-Clause
     */
    if (typeof define !== 'function') {
        var define = require('amdefine')(module, require);
    }
    define(function (require, exports, module) {

        var base64VLQ = require('./base64-vlq');
        var util = require('./util');
        var ArraySet = require('./array-set').ArraySet;

        /**
         * An instance of the SourceMapGenerator represents a source map which is
         * being built incrementally. You may pass an object with the following
         * properties:
         *
         *   - file: The filename of the generated source.
         *   - sourceRoot: A root for all relative URLs in this source map.
         */
        function SourceMapGenerator(aArgs) {
            if (!aArgs) {
                aArgs = {};
            }
            this._file = util.getArg(aArgs, 'file', null);
            this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
            this._sources = new ArraySet();
            this._names = new ArraySet();
            this._mappings = [];
            this._sourcesContents = null;
        }

        SourceMapGenerator.prototype._version = 3;

        /**
         * Creates a new SourceMapGenerator based on a SourceMapConsumer
         *
         * @param aSourceMapConsumer The SourceMap.
         */
        SourceMapGenerator.fromSourceMap =
        function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
            var sourceRoot = aSourceMapConsumer.sourceRoot;
            var generator = new SourceMapGenerator({
                file: aSourceMapConsumer.file,
                sourceRoot: sourceRoot
            });
            aSourceMapConsumer.eachMapping(function (mapping) {
                var newMapping = {
                    generated: {
                        line: mapping.generatedLine,
                        column: mapping.generatedColumn
                    }
                };

                if (mapping.source != null) {
                    newMapping.source = mapping.source;
                    if (sourceRoot != null) {
                        newMapping.source = util.relative(sourceRoot, newMapping.source);
                    }

                    newMapping.original = {
                        line: mapping.originalLine,
                        column: mapping.originalColumn
                    };

                    if (mapping.name != null) {
                        newMapping.name = mapping.name;
                    }
                }

                generator.addMapping(newMapping);
            });
            aSourceMapConsumer.sources.forEach(function (sourceFile) {
                var content = aSourceMapConsumer.sourceContentFor(sourceFile);
                if (content != null) {
                    generator.setSourceContent(sourceFile, content);
                }
            });
            return generator;
        };

        /**
         * Add a single mapping from original source line and column to the generated
         * source's line and column for this source map being created. The mapping
         * object should have the following properties:
         *
         *   - generated: An object with the generated line and column positions.
         *   - original: An object with the original line and column positions.
         *   - source: The original source file (relative to the sourceRoot).
         *   - name: An optional original token name for this mapping.
         */
        SourceMapGenerator.prototype.addMapping =
        function SourceMapGenerator_addMapping(aArgs) {
            var generated = util.getArg(aArgs, 'generated');
            var original = util.getArg(aArgs, 'original', null);
            var source = util.getArg(aArgs, 'source', null);
            var name = util.getArg(aArgs, 'name', null);

            this._validateMapping(generated, original, source, name);

            if (source != null && !this._sources.has(source)) {
                this._sources.add(source);
            }

            if (name != null && !this._names.has(name)) {
                this._names.add(name);
            }

            this._mappings.push({
                generatedLine: generated.line,
                generatedColumn: generated.column,
                originalLine: original != null && original.line,
                originalColumn: original != null && original.column,
                source: source,
                name: name
            });
        };

        /**
         * Set the source content for a source file.
         */
        SourceMapGenerator.prototype.setSourceContent =
        function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
            var source = aSourceFile;
            if (this._sourceRoot != null) {
                source = util.relative(this._sourceRoot, source);
            }

            if (aSourceContent != null) {
                // Add the source content to the _sourcesContents map.
                // Create a new _sourcesContents map if the property is null.
                if (!this._sourcesContents) {
                    this._sourcesContents = {};
                }
                this._sourcesContents[util.toSetString(source)] = aSourceContent;
            } else {
                // Remove the source file from the _sourcesContents map.
                // If the _sourcesContents map is empty, set the property to null.
                delete this._sourcesContents[util.toSetString(source)];
                if (Object.keys(this._sourcesContents).length === 0) {
                    this._sourcesContents = null;
                }
            }
        };

        /**
         * Applies the mappings of a sub-source-map for a specific source file to the
         * source map being generated. Each mapping to the supplied source file is
         * rewritten using the supplied source map. Note: The resolution for the
         * resulting mappings is the minimium of this map and the supplied map.
         *
         * @param aSourceMapConsumer The source map to be applied.
         * @param aSourceFile Optional. The filename of the source file.
         *        If omitted, SourceMapConsumer's file property will be used.
         * @param aSourceMapPath Optional. The dirname of the path to the source map
         *        to be applied. If relative, it is relative to the SourceMapConsumer.
         *        This parameter is needed when the two source maps aren't in the same
         *        directory, and the source map to be applied contains relative source
         *        paths. If so, those relative source paths need to be rewritten
         *        relative to the SourceMapGenerator.
         */
        SourceMapGenerator.prototype.applySourceMap =
        function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
            var sourceFile = aSourceFile;
            // If aSourceFile is omitted, we will use the file property of the SourceMap
            if (aSourceFile == null) {
                if (aSourceMapConsumer.file == null) {
                    throw new Error(
                            'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
                            'or the source map\'s "file" property. Both were omitted.'
                    );
                }
                sourceFile = aSourceMapConsumer.file;
            }
            var sourceRoot = this._sourceRoot;
            // Make "sourceFile" relative if an absolute Url is passed.
            if (sourceRoot != null) {
                sourceFile = util.relative(sourceRoot, sourceFile);
            }
            // Applying the SourceMap can add and remove items from the sources and
            // the names array.
            var newSources = new ArraySet();
            var newNames = new ArraySet();

            // Find mappings for the "sourceFile"
            this._mappings.forEach(function (mapping) {
                if (mapping.source === sourceFile && mapping.originalLine != null) {
                    // Check if it can be mapped by the source map, then update the mapping.
                    var original = aSourceMapConsumer.originalPositionFor({
                        line: mapping.originalLine,
                        column: mapping.originalColumn
                    });
                    if (original.source != null) {
                        // Copy mapping
                        mapping.source = original.source;
                        if (aSourceMapPath != null) {
                            mapping.source = util.join(aSourceMapPath, mapping.source)
                        }
                        if (sourceRoot != null) {
                            mapping.source = util.relative(sourceRoot, mapping.source);
                        }
                        mapping.originalLine = original.line;
                        mapping.originalColumn = original.column;
                        if (original.name != null && mapping.name != null) {
                            // Only use the identifier name if it's an identifier
                            // in both SourceMaps
                            mapping.name = original.name;
                        }
                    }
                }

                var source = mapping.source;
                if (source != null && !newSources.has(source)) {
                    newSources.add(source);
                }

                var name = mapping.name;
                if (name != null && !newNames.has(name)) {
                    newNames.add(name);
                }

            }, this);
            this._sources = newSources;
            this._names = newNames;

            // Copy sourcesContents of applied map.
            aSourceMapConsumer.sources.forEach(function (sourceFile) {
                var content = aSourceMapConsumer.sourceContentFor(sourceFile);
                if (content != null) {
                    if (aSourceMapPath != null) {
                        sourceFile = util.join(aSourceMapPath, sourceFile);
                    }
                    if (sourceRoot != null) {
                        sourceFile = util.relative(sourceRoot, sourceFile);
                    }
                    this.setSourceContent(sourceFile, content);
                }
            }, this);
        };

        /**
         * A mapping can have one of the three levels of data:
         *
         *   1. Just the generated position.
         *   2. The Generated position, original position, and original source.
         *   3. Generated and original position, original source, as well as a name
         *      token.
         *
         * To maintain consistency, we validate that any new mapping being added falls
         * in to one of these categories.
         */
        SourceMapGenerator.prototype._validateMapping =
        function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
                                                    aName) {
            if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
                    && aGenerated.line > 0 && aGenerated.column >= 0
                    && !aOriginal && !aSource && !aName) {
                // Case 1.
                return;
            }
            else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
                         && aOriginal && 'line' in aOriginal && 'column' in aOriginal
                         && aGenerated.line > 0 && aGenerated.column >= 0
                         && aOriginal.line > 0 && aOriginal.column >= 0
                && aSource) {
                // Cases 2 and 3.
                return;
            }
            else {
                throw new Error('Invalid mapping: ' + JSON.stringify({
                    generated: aGenerated,
                    source: aSource,
                    original: aOriginal,
                    name: aName
                }));
            }
        };

        /**
         * Serialize the accumulated mappings in to the stream of base 64 VLQs
         * specified by the source map format.
         */
        SourceMapGenerator.prototype._serializeMappings =
        function SourceMapGenerator_serializeMappings() {
            var previousGeneratedColumn = 0;
            var previousGeneratedLine = 1;
            var previousOriginalColumn = 0;
            var previousOriginalLine = 0;
            var previousName = 0;
            var previousSource = 0;
            var result = '';
            var mapping;

            // The mappings must be guaranteed to be in sorted order before we start
            // serializing them or else the generated line numbers (which are defined
            // via the ';' separators) will be all messed up. Note: it might be more
            // performant to maintain the sorting as we insert them, rather than as we
            // serialize them, but the big O is the same either way.
            this._mappings.sort(util.compareByGeneratedPositions);

            for (var i = 0, len = this._mappings.length; i < len; i++) {
                mapping = this._mappings[i];

                if (mapping.generatedLine !== previousGeneratedLine) {
                    previousGeneratedColumn = 0;
                    while (mapping.generatedLine !== previousGeneratedLine) {
                        result += ';';
                        previousGeneratedLine++;
                    }
                }
                else {
                    if (i > 0) {
                        if (!util.compareByGeneratedPositions(mapping, this._mappings[i - 1])) {
                            continue;
                        }
                        result += ',';
                    }
                }

                result += base64VLQ.encode(mapping.generatedColumn
                    - previousGeneratedColumn);
                previousGeneratedColumn = mapping.generatedColumn;

                if (mapping.source != null) {
                    result += base64VLQ.encode(this._sources.indexOf(mapping.source)
                        - previousSource);
                    previousSource = this._sources.indexOf(mapping.source);

                    // lines are stored 0-based in SourceMap spec version 3
                    result += base64VLQ.encode(mapping.originalLine - 1
                        - previousOriginalLine);
                    previousOriginalLine = mapping.originalLine - 1;

                    result += base64VLQ.encode(mapping.originalColumn
                        - previousOriginalColumn);
                    previousOriginalColumn = mapping.originalColumn;

                    if (mapping.name != null) {
                        result += base64VLQ.encode(this._names.indexOf(mapping.name)
                            - previousName);
                        previousName = this._names.indexOf(mapping.name);
                    }
                }
            }

            return result;
        };

        SourceMapGenerator.prototype._generateSourcesContent =
        function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
            return aSources.map(function (source) {
                if (!this._sourcesContents) {
                    return null;
                }
                if (aSourceRoot != null) {
                    source = util.relative(aSourceRoot, source);
                }
                var key = util.toSetString(source);
                return Object.prototype.hasOwnProperty.call(this._sourcesContents,
                    key)
                    ? this._sourcesContents[key]
                    : null;
            }, this);
        };

        /**
         * Externalize the source map.
         */
        SourceMapGenerator.prototype.toJSON =
        function SourceMapGenerator_toJSON() {
            var map = {
                version: this._version,
                sources: this._sources.toArray(),
                names: this._names.toArray(),
                mappings: this._serializeMappings()
            };
            if (this._file != null) {
                map.file = this._file;
            }
            if (this._sourceRoot != null) {
                map.sourceRoot = this._sourceRoot;
            }
            if (this._sourcesContents) {
                map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
            }

            return map;
        };

        /**
         * Render the source map being generated to a string.
         */
        SourceMapGenerator.prototype.toString =
        function SourceMapGenerator_toString() {
            return JSON.stringify(this);
        };

        exports.SourceMapGenerator = SourceMapGenerator;

    });

},{"./array-set":13,"./base64-vlq":14,"./util":20,"amdefine":21}],19:[function(require,module,exports){
    /* -*- Mode: js; js-indent-level: 2; -*- */
    /*
     * Copyright 2011 Mozilla Foundation and contributors
     * Licensed under the New BSD license. See LICENSE or:
     * http://opensource.org/licenses/BSD-3-Clause
     */
    if (typeof define !== 'function') {
        var define = require('amdefine')(module, require);
    }
    define(function (require, exports, module) {

        var SourceMapGenerator = require('./source-map-generator').SourceMapGenerator;
        var util = require('./util');

        // Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
        // operating systems these days (capturing the result).
        var REGEX_NEWLINE = /(\r?\n)/;

        // Matches a Windows-style newline, or any character.
        var REGEX_CHARACTER = /\r\n|[\s\S]/g;

        /**
         * SourceNodes provide a way to abstract over interpolating/concatenating
         * snippets of generated JavaScript source code while maintaining the line and
         * column information associated with the original source code.
         *
         * @param aLine The original line number.
         * @param aColumn The original column number.
         * @param aSource The original source's filename.
         * @param aChunks Optional. An array of strings which are snippets of
         *        generated JS, or other SourceNodes.
         * @param aName The original identifier.
         */
        function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
            this.children = [];
            this.sourceContents = {};
            this.line = aLine == null ? null : aLine;
            this.column = aColumn == null ? null : aColumn;
            this.source = aSource == null ? null : aSource;
            this.name = aName == null ? null : aName;
            if (aChunks != null) this.add(aChunks);
        }

        /**
         * Creates a SourceNode from generated code and a SourceMapConsumer.
         *
         * @param aGeneratedCode The generated code
         * @param aSourceMapConsumer The SourceMap for the generated code
         * @param aRelativePath Optional. The path that relative sources in the
         *        SourceMapConsumer should be relative to.
         */
        SourceNode.fromStringWithSourceMap =
        function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
            // The SourceNode we want to fill with the generated code
            // and the SourceMap
            var node = new SourceNode();

            // All even indices of this array are one line of the generated code,
            // while all odd indices are the newlines between two adjacent lines
            // (since `REGEX_NEWLINE` captures its match).
            // Processed fragments are removed from this array, by calling `shiftNextLine`.
            var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
            var shiftNextLine = function() {
                var lineContents = remainingLines.shift();
                // The last line of a file might not have a newline.
                var newLine = remainingLines.shift() || "";
                return lineContents + newLine;
            };

            // We need to remember the position of "remainingLines"
            var lastGeneratedLine = 1, lastGeneratedColumn = 0;

            // The generate SourceNodes we need a code range.
            // To extract it current and last mapping is used.
            // Here we store the last mapping.
            var lastMapping = null;

            aSourceMapConsumer.eachMapping(function (mapping) {
                if (lastMapping !== null) {
                    // We add the code from "lastMapping" to "mapping":
                    // First check if there is a new line in between.
                    if (lastGeneratedLine < mapping.generatedLine) {
                        var code = "";
                        // Associate first line with "lastMapping"
                        addMappingWithCode(lastMapping, shiftNextLine());
                        lastGeneratedLine++;
                        lastGeneratedColumn = 0;
                        // The remaining code is added without mapping
                    } else {
                        // There is no new line in between.
                        // Associate the code between "lastGeneratedColumn" and
                        // "mapping.generatedColumn" with "lastMapping"
                        var nextLine = remainingLines[0];
                        var code = nextLine.substr(0, mapping.generatedColumn -
                                                      lastGeneratedColumn);
                        remainingLines[0] = nextLine.substr(mapping.generatedColumn -
                                                            lastGeneratedColumn);
                        lastGeneratedColumn = mapping.generatedColumn;
                        addMappingWithCode(lastMapping, code);
                        // No more remaining code, continue
                        lastMapping = mapping;
                        return;
                    }
                }
                // We add the generated code until the first mapping
                // to the SourceNode without any mapping.
                // Each line is added as separate string.
                while (lastGeneratedLine < mapping.generatedLine) {
                    node.add(shiftNextLine());
                    lastGeneratedLine++;
                }
                if (lastGeneratedColumn < mapping.generatedColumn) {
                    var nextLine = remainingLines[0];
                    node.add(nextLine.substr(0, mapping.generatedColumn));
                    remainingLines[0] = nextLine.substr(mapping.generatedColumn);
                    lastGeneratedColumn = mapping.generatedColumn;
                }
                lastMapping = mapping;
            }, this);
            // We have processed all mappings.
            if (remainingLines.length > 0) {
                if (lastMapping) {
                    // Associate the remaining code in the current line with "lastMapping"
                    addMappingWithCode(lastMapping, shiftNextLine());
                }
                // and add the remaining lines without any mapping
                node.add(remainingLines.join(""));
            }

            // Copy sourcesContent into SourceNode
            aSourceMapConsumer.sources.forEach(function (sourceFile) {
                var content = aSourceMapConsumer.sourceContentFor(sourceFile);
                if (content != null) {
                    if (aRelativePath != null) {
                        sourceFile = util.join(aRelativePath, sourceFile);
                    }
                    node.setSourceContent(sourceFile, content);
                }
            });

            return node;

            function addMappingWithCode(mapping, code) {
                if (mapping === null || mapping.source === undefined) {
                    node.add(code);
                } else {
                    var source = aRelativePath
                        ? util.join(aRelativePath, mapping.source)
                        : mapping.source;
                    node.add(new SourceNode(mapping.originalLine,
                        mapping.originalColumn,
                        source,
                        code,
                        mapping.name));
                }
            }
        };

        /**
         * Add a chunk of generated JS to this source node.
         *
         * @param aChunk A string snippet of generated JS code, another instance of
         *        SourceNode, or an array where each member is one of those things.
         */
        SourceNode.prototype.add = function SourceNode_add(aChunk) {
            if (Array.isArray(aChunk)) {
                aChunk.forEach(function (chunk) {
                    this.add(chunk);
                }, this);
            }
            else if (aChunk instanceof SourceNode || typeof aChunk === "string") {
                if (aChunk) {
                    this.children.push(aChunk);
                }
            }
            else {
                throw new TypeError(
                        "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
                );
            }
            return this;
        };

        /**
         * Add a chunk of generated JS to the beginning of this source node.
         *
         * @param aChunk A string snippet of generated JS code, another instance of
         *        SourceNode, or an array where each member is one of those things.
         */
        SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
            if (Array.isArray(aChunk)) {
                for (var i = aChunk.length-1; i >= 0; i--) {
                    this.prepend(aChunk[i]);
                }
            }
            else if (aChunk instanceof SourceNode || typeof aChunk === "string") {
                this.children.unshift(aChunk);
            }
            else {
                throw new TypeError(
                        "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
                );
            }
            return this;
        };

        /**
         * Walk over the tree of JS snippets in this node and its children. The
         * walking function is called once for each snippet of JS and is passed that
         * snippet and the its original associated source's line/column location.
         *
         * @param aFn The traversal function.
         */
        SourceNode.prototype.walk = function SourceNode_walk(aFn) {
            var chunk;
            for (var i = 0, len = this.children.length; i < len; i++) {
                chunk = this.children[i];
                if (chunk instanceof SourceNode) {
                    chunk.walk(aFn);
                }
                else {
                    if (chunk !== '') {
                        aFn(chunk, { source: this.source,
                            line: this.line,
                            column: this.column,
                            name: this.name });
                    }
                }
            }
        };

        /**
         * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
         * each of `this.children`.
         *
         * @param aSep The separator.
         */
        SourceNode.prototype.join = function SourceNode_join(aSep) {
            var newChildren;
            var i;
            var len = this.children.length;
            if (len > 0) {
                newChildren = [];
                for (i = 0; i < len-1; i++) {
                    newChildren.push(this.children[i]);
                    newChildren.push(aSep);
                }
                newChildren.push(this.children[i]);
                this.children = newChildren;
            }
            return this;
        };

        /**
         * Call String.prototype.replace on the very right-most source snippet. Useful
         * for trimming whitespace from the end of a source node, etc.
         *
         * @param aPattern The pattern to replace.
         * @param aReplacement The thing to replace the pattern with.
         */
        SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
            var lastChild = this.children[this.children.length - 1];
            if (lastChild instanceof SourceNode) {
                lastChild.replaceRight(aPattern, aReplacement);
            }
            else if (typeof lastChild === 'string') {
                this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
            }
            else {
                this.children.push(''.replace(aPattern, aReplacement));
            }
            return this;
        };

        /**
         * Set the source content for a source file. This will be added to the SourceMapGenerator
         * in the sourcesContent field.
         *
         * @param aSourceFile The filename of the source file
         * @param aSourceContent The content of the source file
         */
        SourceNode.prototype.setSourceContent =
        function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
            this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
        };

        /**
         * Walk over the tree of SourceNodes. The walking function is called for each
         * source file content and is passed the filename and source content.
         *
         * @param aFn The traversal function.
         */
        SourceNode.prototype.walkSourceContents =
        function SourceNode_walkSourceContents(aFn) {
            for (var i = 0, len = this.children.length; i < len; i++) {
                if (this.children[i] instanceof SourceNode) {
                    this.children[i].walkSourceContents(aFn);
                }
            }

            var sources = Object.keys(this.sourceContents);
            for (var i = 0, len = sources.length; i < len; i++) {
                aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
            }
        };

        /**
         * Return the string representation of this source node. Walks over the tree
         * and concatenates all the various snippets together to one string.
         */
        SourceNode.prototype.toString = function SourceNode_toString() {
            var str = "";
            this.walk(function (chunk) {
                str += chunk;
            });
            return str;
        };

        /**
         * Returns the string representation of this source node along with a source
         * map.
         */
        SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
            var generated = {
                code: "",
                line: 1,
                column: 0
            };
            var map = new SourceMapGenerator(aArgs);
            var sourceMappingActive = false;
            var lastOriginalSource = null;
            var lastOriginalLine = null;
            var lastOriginalColumn = null;
            var lastOriginalName = null;
            this.walk(function (chunk, original) {
                generated.code += chunk;
                if (original.source !== null
                        && original.line !== null
                    && original.column !== null) {
                    if(lastOriginalSource !== original.source
                           || lastOriginalLine !== original.line
                           || lastOriginalColumn !== original.column
                        || lastOriginalName !== original.name) {
                        map.addMapping({
                            source: original.source,
                            original: {
                                line: original.line,
                                column: original.column
                            },
                            generated: {
                                line: generated.line,
                                column: generated.column
                            },
                            name: original.name
                        });
                    }
                    lastOriginalSource = original.source;
                    lastOriginalLine = original.line;
                    lastOriginalColumn = original.column;
                    lastOriginalName = original.name;
                    sourceMappingActive = true;
                } else if (sourceMappingActive) {
                    map.addMapping({
                        generated: {
                            line: generated.line,
                            column: generated.column
                        }
                    });
                    lastOriginalSource = null;
                    sourceMappingActive = false;
                }
                chunk.match(REGEX_CHARACTER).forEach(function (ch, idx, array) {
                    if (REGEX_NEWLINE.test(ch)) {
                        generated.line++;
                        generated.column = 0;
                        // Mappings end at eol
                        if (idx + 1 === array.length) {
                            lastOriginalSource = null;
                            sourceMappingActive = false;
                        } else if (sourceMappingActive) {
                            map.addMapping({
                                source: original.source,
                                original: {
                                    line: original.line,
                                    column: original.column
                                },
                                generated: {
                                    line: generated.line,
                                    column: generated.column
                                },
                                name: original.name
                            });
                        }
                    } else {
                        generated.column += ch.length;
                    }
                });
            });
            this.walkSourceContents(function (sourceFile, sourceContent) {
                map.setSourceContent(sourceFile, sourceContent);
            });

            return { code: generated.code, map: map };
        };

        exports.SourceNode = SourceNode;

    });

},{"./source-map-generator":18,"./util":20,"amdefine":21}],20:[function(require,module,exports){
    /* -*- Mode: js; js-indent-level: 2; -*- */
    /*
     * Copyright 2011 Mozilla Foundation and contributors
     * Licensed under the New BSD license. See LICENSE or:
     * http://opensource.org/licenses/BSD-3-Clause
     */
    if (typeof define !== 'function') {
        var define = require('amdefine')(module, require);
    }
    define(function (require, exports, module) {

        /**
         * This is a helper function for getting values from parameter/options
         * objects.
         *
         * @param args The object we are extracting values from
         * @param name The name of the property we are getting.
         * @param defaultValue An optional value to return if the property is missing
         * from the object. If this is not specified and the property is missing, an
         * error will be thrown.
         */
        function getArg(aArgs, aName, aDefaultValue) {
            if (aName in aArgs) {
                return aArgs[aName];
            } else if (arguments.length === 3) {
                return aDefaultValue;
            } else {
                throw new Error('"' + aName + '" is a required argument.');
            }
        }
        exports.getArg = getArg;

        var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.]*)(?::(\d+))?(\S*)$/;
        var dataUrlRegexp = /^data:.+\,.+$/;

        function urlParse(aUrl) {
            var match = aUrl.match(urlRegexp);
            if (!match) {
                return null;
            }
            return {
                scheme: match[1],
                auth: match[2],
                host: match[3],
                port: match[4],
                path: match[5]
            };
        }
        exports.urlParse = urlParse;

        function urlGenerate(aParsedUrl) {
            var url = '';
            if (aParsedUrl.scheme) {
                url += aParsedUrl.scheme + ':';
            }
            url += '//';
            if (aParsedUrl.auth) {
                url += aParsedUrl.auth + '@';
            }
            if (aParsedUrl.host) {
                url += aParsedUrl.host;
            }
            if (aParsedUrl.port) {
                url += ":" + aParsedUrl.port
            }
            if (aParsedUrl.path) {
                url += aParsedUrl.path;
            }
            return url;
        }
        exports.urlGenerate = urlGenerate;

        /**
         * Normalizes a path, or the path portion of a URL:
         *
         * - Replaces consequtive slashes with one slash.
         * - Removes unnecessary '.' parts.
         * - Removes unnecessary '<dir>/..' parts.
         *
         * Based on code in the Node.js 'path' core module.
         *
         * @param aPath The path or url to normalize.
         */
        function normalize(aPath) {
            var path = aPath;
            var url = urlParse(aPath);
            if (url) {
                if (!url.path) {
                    return aPath;
                }
                path = url.path;
            }
            var isAbsolute = (path.charAt(0) === '/');

            var parts = path.split(/\/+/);
            for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
                part = parts[i];
                if (part === '.') {
                    parts.splice(i, 1);
                } else if (part === '..') {
                    up++;
                } else if (up > 0) {
                    if (part === '') {
                        // The first part is blank if the path is absolute. Trying to go
                        // above the root is a no-op. Therefore we can remove all '..' parts
                        // directly after the root.
                        parts.splice(i + 1, up);
                        up = 0;
                    } else {
                        parts.splice(i, 2);
                        up--;
                    }
                }
            }
            path = parts.join('/');

            if (path === '') {
                path = isAbsolute ? '/' : '.';
            }

            if (url) {
                url.path = path;
                return urlGenerate(url);
            }
            return path;
        }
        exports.normalize = normalize;

        /**
         * Joins two paths/URLs.
         *
         * @param aRoot The root path or URL.
         * @param aPath The path or URL to be joined with the root.
         *
         * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
         *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
         *   first.
         * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
         *   is updated with the result and aRoot is returned. Otherwise the result
         *   is returned.
         *   - If aPath is absolute, the result is aPath.
         *   - Otherwise the two paths are joined with a slash.
         * - Joining for example 'http://' and 'www.example.com' is also supported.
         */
        function join(aRoot, aPath) {
            if (aRoot === "") {
                aRoot = ".";
            }
            if (aPath === "") {
                aPath = ".";
            }
            var aPathUrl = urlParse(aPath);
            var aRootUrl = urlParse(aRoot);
            if (aRootUrl) {
                aRoot = aRootUrl.path || '/';
            }

            // `join(foo, '//www.example.org')`
            if (aPathUrl && !aPathUrl.scheme) {
                if (aRootUrl) {
                    aPathUrl.scheme = aRootUrl.scheme;
                }
                return urlGenerate(aPathUrl);
            }

            if (aPathUrl || aPath.match(dataUrlRegexp)) {
                return aPath;
            }

            // `join('http://', 'www.example.com')`
            if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
                aRootUrl.host = aPath;
                return urlGenerate(aRootUrl);
            }

            var joined = aPath.charAt(0) === '/'
                ? aPath
                : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);

            if (aRootUrl) {
                aRootUrl.path = joined;
                return urlGenerate(aRootUrl);
            }
            return joined;
        }
        exports.join = join;

        /**
         * Make a path relative to a URL or another path.
         *
         * @param aRoot The root path or URL.
         * @param aPath The path or URL to be made relative to aRoot.
         */
        function relative(aRoot, aPath) {
            aRoot = aRoot.replace(/\/$/, '');

            // XXX: It is possible to remove this block, and the tests still pass!
            var url = urlParse(aRoot);
            if (aPath.charAt(0) == "/" && url && url.path == "/") {
                return aPath.slice(1);
            }

            return aPath.indexOf(aRoot + '/') === 0
                ? aPath.substr(aRoot.length + 1)
                : aPath;
        }
        exports.relative = relative;

        /**
         * Because behavior goes wacky when you set `__proto__` on objects, we
         * have to prefix all the strings in our set with an arbitrary character.
         *
         * See https://github.com/mozilla/source-map/pull/31 and
         * https://github.com/mozilla/source-map/issues/30
         *
         * @param String aStr
         */
        function toSetString(aStr) {
            return '$' + aStr;
        }
        exports.toSetString = toSetString;

        function fromSetString(aStr) {
            return aStr.substr(1);
        }
        exports.fromSetString = fromSetString;

        function strcmp(aStr1, aStr2) {
            var s1 = aStr1 || "";
            var s2 = aStr2 || "";
            return (s1 > s2) - (s1 < s2);
        }

        /**
         * Comparator between two mappings where the original positions are compared.
         *
         * Optionally pass in `true` as `onlyCompareGenerated` to consider two
         * mappings with the same original source/line/column, but different generated
         * line and column the same. Useful when searching for a mapping with a
         * stubbed out mapping.
         */
        function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
            var cmp;

            cmp = strcmp(mappingA.source, mappingB.source);
            if (cmp) {
                return cmp;
            }

            cmp = mappingA.originalLine - mappingB.originalLine;
            if (cmp) {
                return cmp;
            }

            cmp = mappingA.originalColumn - mappingB.originalColumn;
            if (cmp || onlyCompareOriginal) {
                return cmp;
            }

            cmp = strcmp(mappingA.name, mappingB.name);
            if (cmp) {
                return cmp;
            }

            cmp = mappingA.generatedLine - mappingB.generatedLine;
            if (cmp) {
                return cmp;
            }

            return mappingA.generatedColumn - mappingB.generatedColumn;
        };
        exports.compareByOriginalPositions = compareByOriginalPositions;

        /**
         * Comparator between two mappings where the generated positions are
         * compared.
         *
         * Optionally pass in `true` as `onlyCompareGenerated` to consider two
         * mappings with the same generated line and column, but different
         * source/name/original line and column the same. Useful when searching for a
         * mapping with a stubbed out mapping.
         */
        function compareByGeneratedPositions(mappingA, mappingB, onlyCompareGenerated) {
            var cmp;

            cmp = mappingA.generatedLine - mappingB.generatedLine;
            if (cmp) {
                return cmp;
            }

            cmp = mappingA.generatedColumn - mappingB.generatedColumn;
            if (cmp || onlyCompareGenerated) {
                return cmp;
            }

            cmp = strcmp(mappingA.source, mappingB.source);
            if (cmp) {
                return cmp;
            }

            cmp = mappingA.originalLine - mappingB.originalLine;
            if (cmp) {
                return cmp;
            }

            cmp = mappingA.originalColumn - mappingB.originalColumn;
            if (cmp) {
                return cmp;
            }

            return strcmp(mappingA.name, mappingB.name);
        };
        exports.compareByGeneratedPositions = compareByGeneratedPositions;

    });

},{"amdefine":21}],21:[function(require,module,exports){
    (function (process,__filename){
        /** vim: et:ts=4:sw=4:sts=4
         * @license amdefine 0.1.0 Copyright (c) 2011, The Dojo Foundation All Rights Reserved.
         * Available via the MIT or new BSD license.
         * see: http://github.com/jrburke/amdefine for details
         */

        /*jslint node: true */
        /*global module, process */
        'use strict';

        /**
         * Creates a define for node.
         * @param {Object} module the "module" object that is defined by Node for the
         * current module.
         * @param {Function} [requireFn]. Node's require function for the current module.
         * It only needs to be passed in Node versions before 0.5, when module.require
         * did not exist.
         * @returns {Function} a define function that is usable for the current node
         * module.
         */
        function amdefine(module, requireFn) {
            'use strict';
            var defineCache = {},
                loaderCache = {},
                alreadyCalled = false,
                path = require('path'),
                makeRequire, stringRequire;

            /**
             * Trims the . and .. from an array of path segments.
             * It will keep a leading path segment if a .. will become
             * the first path segment, to help with module name lookups,
             * which act like paths, but can be remapped. But the end result,
             * all paths that use this function should look normalized.
             * NOTE: this method MODIFIES the input array.
             * @param {Array} ary the array of path segments.
             */
            function trimDots(ary) {
                var i, part;
                for (i = 0; ary[i]; i+= 1) {
                    part = ary[i];
                    if (part === '.') {
                        ary.splice(i, 1);
                        i -= 1;
                    } else if (part === '..') {
                        if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
                            //End of the line. Keep at least one non-dot
                            //path segment at the front so it can be mapped
                            //correctly to disk. Otherwise, there is likely
                            //no path mapping for a path starting with '..'.
                            //This can still fail, but catches the most reasonable
                            //uses of ..
                            break;
                        } else if (i > 0) {
                            ary.splice(i - 1, 2);
                            i -= 2;
                        }
                    }
                }
            }

            function normalize(name, baseName) {
                var baseParts;

                //Adjust any relative paths.
                if (name && name.charAt(0) === '.') {
                    //If have a base name, try to normalize against it,
                    //otherwise, assume it is a top-level require that will
                    //be relative to baseUrl in the end.
                    if (baseName) {
                        baseParts = baseName.split('/');
                        baseParts = baseParts.slice(0, baseParts.length - 1);
                        baseParts = baseParts.concat(name.split('/'));
                        trimDots(baseParts);
                        name = baseParts.join('/');
                    }
                }

                return name;
            }

            /**
             * Create the normalize() function passed to a loader plugin's
             * normalize method.
             */
            function makeNormalize(relName) {
                return function (name) {
                    return normalize(name, relName);
                };
            }

            function makeLoad(id) {
                function load(value) {
                    loaderCache[id] = value;
                }

                load.fromText = function (id, text) {
                    //This one is difficult because the text can/probably uses
                    //define, and any relative paths and requires should be relative
                    //to that id was it would be found on disk. But this would require
                    //bootstrapping a module/require fairly deeply from node core.
                    //Not sure how best to go about that yet.
                    throw new Error('amdefine does not implement load.fromText');
                };

                return load;
            }

            makeRequire = function (systemRequire, exports, module, relId) {
                function amdRequire(deps, callback) {
                    if (typeof deps === 'string') {
                        //Synchronous, single module require('')
                        return stringRequire(systemRequire, exports, module, deps, relId);
                    } else {
                        //Array of dependencies with a callback.

                        //Convert the dependencies to modules.
                        deps = deps.map(function (depName) {
                            return stringRequire(systemRequire, exports, module, depName, relId);
                        });

                        //Wait for next tick to call back the require call.
                        process.nextTick(function () {
                            callback.apply(null, deps);
                        });
                    }
                }

                amdRequire.toUrl = function (filePath) {
                    if (filePath.indexOf('.') === 0) {
                        return normalize(filePath, path.dirname(module.filename));
                    } else {
                        return filePath;
                    }
                };

                return amdRequire;
            };

            //Favor explicit value, passed in if the module wants to support Node 0.4.
            requireFn = requireFn || function req() {
                return module.require.apply(module, arguments);
            };

            function runFactory(id, deps, factory) {
                var r, e, m, result;

                if (id) {
                    e = loaderCache[id] = {};
                    m = {
                        id: id,
                        uri: __filename,
                        exports: e
                    };
                    r = makeRequire(requireFn, e, m, id);
                } else {
                    //Only support one define call per file
                    if (alreadyCalled) {
                        throw new Error('amdefine with no module ID cannot be called more than once per file.');
                    }
                    alreadyCalled = true;

                    //Use the real variables from node
                    //Use module.exports for exports, since
                    //the exports in here is amdefine exports.
                    e = module.exports;
                    m = module;
                    r = makeRequire(requireFn, e, m, module.id);
                }

                //If there are dependencies, they are strings, so need
                //to convert them to dependency values.
                if (deps) {
                    deps = deps.map(function (depName) {
                        return r(depName);
                    });
                }

                //Call the factory with the right dependencies.
                if (typeof factory === 'function') {
                    result = factory.apply(m.exports, deps);
                } else {
                    result = factory;
                }

                if (result !== undefined) {
                    m.exports = result;
                    if (id) {
                        loaderCache[id] = m.exports;
                    }
                }
            }

            stringRequire = function (systemRequire, exports, module, id, relId) {
                //Split the ID by a ! so that
                var index = id.indexOf('!'),
                    originalId = id,
                    prefix, plugin;

                if (index === -1) {
                    id = normalize(id, relId);

                    //Straight module lookup. If it is one of the special dependencies,
                    //deal with it, otherwise, delegate to node.
                    if (id === 'require') {
                        return makeRequire(systemRequire, exports, module, relId);
                    } else if (id === 'exports') {
                        return exports;
                    } else if (id === 'module') {
                        return module;
                    } else if (loaderCache.hasOwnProperty(id)) {
                        return loaderCache[id];
                    } else if (defineCache[id]) {
                        runFactory.apply(null, defineCache[id]);
                        return loaderCache[id];
                    } else {
                        if(systemRequire) {
                            return systemRequire(originalId);
                        } else {
                            throw new Error('No module with ID: ' + id);
                        }
                    }
                } else {
                    //There is a plugin in play.
                    prefix = id.substring(0, index);
                    id = id.substring(index + 1, id.length);

                    plugin = stringRequire(systemRequire, exports, module, prefix, relId);

                    if (plugin.normalize) {
                        id = plugin.normalize(id, makeNormalize(relId));
                    } else {
                        //Normalize the ID normally.
                        id = normalize(id, relId);
                    }

                    if (loaderCache[id]) {
                        return loaderCache[id];
                    } else {
                        plugin.load(id, makeRequire(systemRequire, exports, module, relId), makeLoad(id), {});

                        return loaderCache[id];
                    }
                }
            };

            //Create a define function specific to the module asking for amdefine.
            function define(id, deps, factory) {
                if (Array.isArray(id)) {
                    factory = deps;
                    deps = id;
                    id = undefined;
                } else if (typeof id !== 'string') {
                    factory = id;
                    id = deps = undefined;
                }

                if (deps && !Array.isArray(deps)) {
                    factory = deps;
                    deps = undefined;
                }

                if (!deps) {
                    deps = ['require', 'exports', 'module'];
                }

                //Set up properties for this module. If an ID, then use
                //internal cache. If no ID, then use the external variables
                //for this node module.
                if (id) {
                    //Put the module in deep freeze until there is a
                    //require call for it.
                    defineCache[id] = [id, deps, factory];
                } else {
                    runFactory(id, deps, factory);
                }
            }

            //define.require, which has access to all the values in the
            //cache. Useful for AMD modules that all have IDs in the file,
            //but need to finally export a value to node based on one of those
            //IDs.
            define.require = function (id) {
                if (loaderCache[id]) {
                    return loaderCache[id];
                }

                if (defineCache[id]) {
                    runFactory.apply(null, defineCache[id]);
                    return loaderCache[id];
                }
            };

            define.amd = {};

            return define;
        }

        module.exports = amdefine;

    }).call(this,require('_process'),"/../../node_modules/css/node_modules/source-map/node_modules/amdefine/amdefine.js")
},{"_process":25,"path":24}],22:[function(require,module,exports){
// Copyright 2014 Simon Lydell
// X11 (“MIT”) Licensed. (See LICENSE.)

    var path = require("path")

    "use strict"

    function urix(aPath) {
        if (path.sep === "\\") {
            return aPath
                .replace(/\\/g, "/")
                .replace(/^[a-z]:\/?/i, "/")
        }
        return aPath
    }

    module.exports = urix

},{"path":24}],23:[function(require,module,exports){

},{}],24:[function(require,module,exports){
    (function (process){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// resolves . and .. elements in a path array with directory names there
// must be no slashes, empty elements, or device names (c:\) in the array
// (so also no leading and trailing slashes - it does not distinguish
// relative and absolute paths)
        function normalizeArray(parts, allowAboveRoot) {
            // if the path tries to go above the root, `up` ends up > 0
            var up = 0;
            for (var i = parts.length - 1; i >= 0; i--) {
                var last = parts[i];
                if (last === '.') {
                    parts.splice(i, 1);
                } else if (last === '..') {
                    parts.splice(i, 1);
                    up++;
                } else if (up) {
                    parts.splice(i, 1);
                    up--;
                }
            }

            // if the path is allowed to go above the root, restore leading ..s
            if (allowAboveRoot) {
                for (; up--; up) {
                    parts.unshift('..');
                }
            }

            return parts;
        }

// Split a filename into [root, dir, basename, ext], unix version
// 'root' is just a slash, or nothing.
        var splitPathRe =
            /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
        var splitPath = function(filename) {
            return splitPathRe.exec(filename).slice(1);
        };

// path.resolve([from ...], to)
// posix version
        exports.resolve = function() {
            var resolvedPath = '',
                resolvedAbsolute = false;

            for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
                var path = (i >= 0) ? arguments[i] : process.cwd();

                // Skip empty and invalid entries
                if (typeof path !== 'string') {
                    throw new TypeError('Arguments to path.resolve must be strings');
                } else if (!path) {
                    continue;
                }

                resolvedPath = path + '/' + resolvedPath;
                resolvedAbsolute = path.charAt(0) === '/';
            }

            // At this point the path should be resolved to a full absolute path, but
            // handle relative paths to be safe (might happen when process.cwd() fails)

            // Normalize the path
            resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
                return !!p;
            }), !resolvedAbsolute).join('/');

            return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
        };

// path.normalize(path)
// posix version
        exports.normalize = function(path) {
            var isAbsolute = exports.isAbsolute(path),
                trailingSlash = substr(path, -1) === '/';

            // Normalize the path
            path = normalizeArray(filter(path.split('/'), function(p) {
                return !!p;
            }), !isAbsolute).join('/');

            if (!path && !isAbsolute) {
                path = '.';
            }
            if (path && trailingSlash) {
                path += '/';
            }

            return (isAbsolute ? '/' : '') + path;
        };

// posix version
        exports.isAbsolute = function(path) {
            return path.charAt(0) === '/';
        };

// posix version
        exports.join = function() {
            var paths = Array.prototype.slice.call(arguments, 0);
            return exports.normalize(filter(paths, function(p, index) {
                if (typeof p !== 'string') {
                    throw new TypeError('Arguments to path.join must be strings');
                }
                return p;
            }).join('/'));
        };


// path.relative(from, to)
// posix version
        exports.relative = function(from, to) {
            from = exports.resolve(from).substr(1);
            to = exports.resolve(to).substr(1);

            function trim(arr) {
                var start = 0;
                for (; start < arr.length; start++) {
                    if (arr[start] !== '') break;
                }

                var end = arr.length - 1;
                for (; end >= 0; end--) {
                    if (arr[end] !== '') break;
                }

                if (start > end) return [];
                return arr.slice(start, end - start + 1);
            }

            var fromParts = trim(from.split('/'));
            var toParts = trim(to.split('/'));

            var length = Math.min(fromParts.length, toParts.length);
            var samePartsLength = length;
            for (var i = 0; i < length; i++) {
                if (fromParts[i] !== toParts[i]) {
                    samePartsLength = i;
                    break;
                }
            }

            var outputParts = [];
            for (var i = samePartsLength; i < fromParts.length; i++) {
                outputParts.push('..');
            }

            outputParts = outputParts.concat(toParts.slice(samePartsLength));

            return outputParts.join('/');
        };

        exports.sep = '/';
        exports.delimiter = ':';

        exports.dirname = function(path) {
            var result = splitPath(path),
                root = result[0],
                dir = result[1];

            if (!root && !dir) {
                // No dirname whatsoever
                return '.';
            }

            if (dir) {
                // It has a dirname, strip trailing slash
                dir = dir.substr(0, dir.length - 1);
            }

            return root + dir;
        };


        exports.basename = function(path, ext) {
            var f = splitPath(path)[2];
            // TODO: make this comparison case-insensitive on windows?
            if (ext && f.substr(-1 * ext.length) === ext) {
                f = f.substr(0, f.length - ext.length);
            }
            return f;
        };


        exports.extname = function(path) {
            return splitPath(path)[3];
        };

        function filter (xs, f) {
            if (xs.filter) return xs.filter(f);
            var res = [];
            for (var i = 0; i < xs.length; i++) {
                if (f(xs[i], i, xs)) res.push(xs[i]);
            }
            return res;
        }

// String.prototype.substr - negative index don't work in IE8
        var substr = 'ab'.substr(-1) === 'b'
                ? function (str, start, len) { return str.substr(start, len) }
                : function (str, start, len) {
                if (start < 0) start = str.length + start;
                return str.substr(start, len);
            }
            ;

    }).call(this,require('_process'))
},{"_process":25}],25:[function(require,module,exports){
// shim for using process in browser

    var process = module.exports = {};

    process.nextTick = (function () {
        var canSetImmediate = typeof window !== 'undefined'
            && window.setImmediate;
        var canPost = typeof window !== 'undefined'
                          && window.postMessage && window.addEventListener
            ;

        if (canSetImmediate) {
            return function (f) { return window.setImmediate(f) };
        }

        if (canPost) {
            var queue = [];
            window.addEventListener('message', function (ev) {
                var source = ev.source;
                if ((source === window || source === null) && ev.data === 'process-tick') {
                    ev.stopPropagation();
                    if (queue.length > 0) {
                        var fn = queue.shift();
                        fn();
                    }
                }
            }, true);

            return function nextTick(fn) {
                queue.push(fn);
                window.postMessage('process-tick', '*');
            };
        }

        return function nextTick(fn) {
            setTimeout(fn, 0);
        };
    })();

    process.title = 'browser';
    process.browser = true;
    process.env = {};
    process.argv = [];

    function noop() {}

    process.on = noop;
    process.addListener = noop;
    process.once = noop;
    process.off = noop;
    process.removeListener = noop;
    process.removeAllListeners = noop;
    process.emit = noop;

    process.binding = function (name) {
        throw new Error('process.binding is not supported');
    }

// TODO(shtylman)
    process.cwd = function () { return '/' };
    process.chdir = function (dir) {
        throw new Error('process.chdir is not supported');
    };

},{}]},{},[1]);
